int NaClNameServiceCtor(struct NaClNameService *self,
NaClThreadIfFactoryFunction thread_factory_fn,
void *thread_factory_data) {
int retval = 0; /* fail */
NaClLog(4, "Entered NaClNameServiceCtor\n");
if (!NaClSimpleLtdServiceCtor(&self->base,
kNaClNameServiceHandlers,
NACL_NAME_SERVICE_CONNECTION_MAX,
thread_factory_fn,
thread_factory_data)) {
NaClLog(4, "NaClSimpleLtdServiceCtor failed\n");
goto done;
}
if (!NaClMutexCtor(&self->mu)) {
NaClLog(4, "NaClMutexCtor failed\n");
goto abort_mu;
}
NACL_VTBL(NaClRefCount, self) = (struct NaClRefCountVtbl *)
&kNaClNameServiceVtbl;
/* success return path */
self->head = (struct NaClNameServiceEntry *) NULL;
retval = 1;
goto done;
/* cleanup unwind */
abort_mu: /* mutex ctor failed */
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
done:
return retval;
}
static void NaClManifestProxyConnectionDtor(struct NaClRefCount *vself) {
struct NaClManifestProxyConnection *self =
(struct NaClManifestProxyConnection *) vself;
NaClLog(4,
"Entered NaClManifestProxyConnectionDtor: self 0x%"NACL_PRIxPTR"\n",
(uintptr_t) self);
NaClXMutexLock(&self->mu);
while (!self->channel_initialized) {
NaClLog(4,
"NaClManifestProxyConnectionDtor:"
" waiting for connection initialization\n");
NaClXCondVarWait(&self->cv, &self->mu);
}
NaClXMutexUnlock(&self->mu);
NaClLog(4, "NaClManifestProxyConnectionDtor: dtoring\n");
NaClCondVarDtor(&self->cv);
NaClMutexDtor(&self->mu);
NaClSrpcDtor(&self->client_channel);
NACL_VTBL(NaClSimpleServiceConnection, self) =
&kNaClSimpleServiceConnectionVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
int NaClReverseThreadIfCtor_protected(
struct NaClReverseCountingThreadInterface *self,
void *factory_data,
NaClThreadIfStartFunction fn_ptr,
void *thread_data,
size_t thread_stack_size) {
struct NaClReverseService *nrsp = (struct NaClReverseService *) factory_data;
NaClLog(3, "Entered NaClReverseThreadIfCtor_protected\n");
if (!NaClThreadInterfaceCtor_protected(
(struct NaClThreadInterface *) self,
NaClReverseThreadIfFactoryFn,
NaClRefCountRef((struct NaClRefCount *) nrsp),
fn_ptr,
thread_data,
thread_stack_size)) {
NaClLog(4, "NaClThreadInterfaceCtor_protected failed\n");
NaClRefCountUnref((struct NaClRefCount *) nrsp);
return 0;
}
self->reverse_service = nrsp;
(*NACL_VTBL(NaClReverseService, nrsp)->ThreadCountIncr)(nrsp);
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClReverseThreadInterfaceVtbl;
NaClLog(3, "Leaving NaClAddrSpSquattingThreadIfCtor_protected\n");
return 1;
}
int NaClGetFileOriginInfo(struct NaClDesc *desc,
struct NaClRichFileInfo *info) {
int32_t metadata_type;
uint8_t *buffer = NULL;
uint32_t buffer_length = 0;
int status;
/* Get the buffer length. */
metadata_type = NACL_VTBL(NaClDesc, desc)->GetMetadata(
desc,
&buffer_length,
NULL);
if (metadata_type != NACL_DESC_METADATA_ORIGIN_INFO_TYPE)
return 1;
buffer = (uint8_t *) malloc(buffer_length);
if (NULL == buffer)
return 1;
metadata_type = NACL_VTBL(NaClDesc, desc)->GetMetadata(
desc,
&buffer_length,
buffer);
if (metadata_type != NACL_DESC_METADATA_ORIGIN_INFO_TYPE)
return 1;
status = NaClDeserializeNaClDescMetadata(buffer, buffer_length, info);
free(buffer);
return status;
}
void NaClReverseInterfaceDtor(struct NaClRefCount *vself) {
struct NaClReverseInterface *self =
(struct NaClReverseInterface *) vself;
NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
static void NaClDescRngDtor(struct NaClRefCount *vself) {
struct NaClDescRng *self = (struct NaClDescRng *) vself;
(*NACL_VTBL(NaClSecureRngIf, &self->rng)->Dtor)(
(struct NaClSecureRngIf *) &self->rng);
NACL_VTBL(NaClDesc, self) = &kNaClDescVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
}
ssize_t NaClDescQuotaPWrite(struct NaClDesc *vself,
void const *buf,
size_t len,
nacl_off64_t offset) {
struct NaClDescQuota *self = (struct NaClDescQuota *) vself;
uint64_t len_u64;
int64_t allowed;
ssize_t rv;
if (0 == len) {
allowed = 0;
} else {
NACL_COMPILE_TIME_ASSERT(SIZE_T_MAX <= NACL_UMAX_VAL(uint64_t));
/*
* Write can always return a short, non-zero transfer count.
*/
len_u64 = (uint64_t) len;
/* get rid of the always-true/always-false comparison warning */
if (len_u64 > NACL_MAX_VAL(int64_t)) {
len = (size_t) NACL_MAX_VAL(int64_t);
}
if (NULL == self->quota_interface) {
/* If there is no quota_interface, do not allow writes. */
allowed = 0;
} else {
allowed = (*NACL_VTBL(NaClDescQuotaInterface, self->quota_interface)->
WriteRequest)(self->quota_interface,
self->file_id, offset, len);
}
if (allowed <= 0) {
rv = -NACL_ABI_EDQUOT;
goto abort;
}
/*
* allowed <= len should be a post-condition, but we check for
* it anyway.
*/
if ((uint64_t) allowed > len) {
NaClLog(LOG_WARNING,
("NaClDescQuotaPWrite: WriteRequest returned an allowed quota"
" that is larger than that requested; reducing to original"
" request amount.\n"));
allowed = len;
}
}
/*
* It is possible for Write to write fewer than bytes than the quota
* that was granted, in which case quota will leak.
* TODO(sehr,bsy): eliminate quota leakage.
*/
rv = (*NACL_VTBL(NaClDesc, self->desc)->PWrite)(self->desc,
buf, (size_t) allowed,
offset);
abort:
return rv;
}
void NaClSimpleServiceDtor(struct NaClRefCount *vself) {
struct NaClSimpleService *self = (struct NaClSimpleService *) vself;
NaClRefCountSafeUnref((struct NaClRefCount *) self->bound_and_cap[0]);
NaClRefCountSafeUnref((struct NaClRefCount *) self->bound_and_cap[1]);
NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
void NaClReverseHostInterfaceDtor(struct NaClRefCount *vself) {
struct NaClReverseHostInterface *self =
(struct NaClReverseHostInterface *) vself;
NaClRefCountUnref((struct NaClRefCount *) self->server);
NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
void NaClKernelServiceDtor(struct NaClRefCount *vself) {
struct NaClKernelService *self = (struct NaClKernelService *) vself;
NaClRefCountUnref((struct NaClRefCount *) self->runtime_host);
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClSimpleServiceVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
void NaClReverseThreadIfDtor(struct NaClRefCount *vself) {
struct NaClReverseCountingThreadInterface *self =
(struct NaClReverseCountingThreadInterface *) vself;
NaClRefCountUnref((struct NaClRefCount *) self->reverse_service);
self->reverse_service = NULL;
NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
static void NaClDescPostMessageDtor(struct NaClRefCount *vself) {
struct NaClDescPostMessage *self = (struct NaClDescPostMessage *) vself;
NaClLog(4, "Entered NaClDescPostMessageDtor\n");
self->nap = NULL;
NACL_VTBL(NaClRefCount, vself) =
(struct NaClRefCountVtbl const *) &kNaClDescVtbl;
(*NACL_VTBL(NaClRefCount, vself)->Dtor)(vself);
NaClLog(4, "Leaving NaClDescPostMessageDtor\n");
}
void NaClSimpleServiceConnectionDtor(struct NaClRefCount *vself) {
struct NaClSimpleServiceConnection *self =
(struct NaClSimpleServiceConnection *) vself;
NaClRefCountUnref((struct NaClRefCount *) self->server);
NaClRefCountUnref((struct NaClRefCount *) self->connected_socket);
NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
static void NaClManifestProxyDtor(struct NaClRefCount *vself) {
struct NaClManifestProxy *self =
(struct NaClManifestProxy *) vself;
NaClRefCountUnref((struct NaClRefCount *) self->server);
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClSimpleServiceVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
void NaClSimpleLtdServiceDtor(struct NaClRefCount *vself) {
struct NaClSimpleLtdService *self =
(struct NaClSimpleLtdService *) vself;
CHECK(0 == self->num_clients);
NaClCondVarDtor(&self->cv);
NaClMutexDtor(&self->mu);
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClSimpleServiceVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
}
void NaClDescQuotaDtor(struct NaClRefCount *vself) {
struct NaClDescQuota *self = (struct NaClDescQuota *) vself;
NaClRefCountSafeUnref((struct NaClRefCount *) self->quota_interface);
NaClRefCountUnref((struct NaClRefCount *) self->desc);
self->desc = NULL;
NaClMutexDtor(&self->mu);
NACL_VTBL(NaClDesc, self) = &kNaClDescVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
}
int NaClSimpleServiceAcceptConnection(
struct NaClSimpleService *self,
struct NaClSimpleServiceConnection **out) {
int status = -NACL_ABI_EINVAL;
struct NaClSimpleServiceConnection *conn = NULL;
struct NaClDesc *connected_desc = NULL;
NaClLog(4, "Entered NaClSimpleServiceAcceptConnection\n");
conn = malloc(sizeof *conn);
if (NULL == conn) {
return -NACL_ABI_ENOMEM;
}
/* NB: conn is allocated but not constructed */
status = (*NACL_VTBL(NaClDesc, self->bound_and_cap[0])->
AcceptConn)(self->bound_and_cap[0], &connected_desc);
if (0 != status) {
NaClLog(4, "Accept failed\n");
free(conn);
conn = NULL;
goto cleanup;
}
NaClLog(4,
"connected_desc is 0x%"NACL_PRIxPTR"\n",
(uintptr_t) connected_desc);
status = (*NACL_VTBL(NaClSimpleService, self)->ConnectionFactory)(
self,
connected_desc,
&conn);
if (0 != status) {
NaClLog(4, "ConnectionFactory failed\n");
goto cleanup;
}
/* all okay! */
NaClLog(4,
"NaClSimpleServiceAcceptConnection: conn is 0x%"NACL_PRIxPTR"\n",
(uintptr_t) conn);
NaClLog(4,
"NaClSimpleServiceAcceptConnection: out is 0x%"NACL_PRIxPTR"\n",
(uintptr_t) out);
*out = conn;
status = 0;
cleanup:
NaClRefCountSafeUnref((struct NaClRefCount *) connected_desc);
NaClLog(4, "Leaving NaClSimpleServiceAcceptConnection, status %d\n", status);
return status;
}
ssize_t NaClDescQuotaSendMsg(struct NaClDesc *vself,
const struct NaClImcTypedMsgHdr *nitmhp,
int flags) {
struct NaClDescQuota *self = (struct NaClDescQuota *) vself;
return (*NACL_VTBL(NaClDesc, self->desc)->SendMsg)(self->desc, nitmhp, flags);
}
int NaClVmmapEntryMaxProt(struct NaClVmmapEntry *entry) {
int flags = PROT_NONE;
if (entry->desc != NULL && 0 == (entry->flags & NACL_ABI_MAP_PRIVATE)) {
int o_flags = (*NACL_VTBL(NaClDesc, entry->desc)->GetFlags)(entry->desc);
switch (o_flags & NACL_ABI_O_ACCMODE) {
case NACL_ABI_O_RDONLY:
flags = NACL_ABI_PROT_READ;
break;
case NACL_ABI_O_WRONLY:
flags = NACL_ABI_PROT_WRITE;
break;
case NACL_ABI_O_RDWR:
flags = NACL_ABI_PROT_READ | NACL_ABI_PROT_WRITE;
break;
default:
NaClLog(LOG_FATAL, "Internal error: illegal O_ACCMODE\n");
break;
}
} else {
flags = NACL_ABI_PROT_READ | NACL_ABI_PROT_WRITE;
}
return flags;
}
/*
* Enumerate all names in the manifest.
*/
static void NaClReverseServiceManifestListRpc(
struct NaClSrpcRpc *rpc,
struct NaClSrpcArg **in_args,
struct NaClSrpcArg **out_args,
struct NaClSrpcClosure *done_cls) {
struct NaClReverseService *nrsp =
(struct NaClReverseService *) rpc->channel->server_instance_data;
char *buffer = out_args[0]->arrays.carr;
nacl_abi_size_t buffer_bytes = out_args[0]->u.count;
size_t size;
UNREFERENCED_PARAMETER(in_args);
NaClLog(4, "Entered ManifestListRpc: 0x%08"NACL_PRIxPTR"\n",
(uintptr_t) nrsp);
if ((size = (*NACL_VTBL(NaClReverseInterface, nrsp->iface)->
EnumerateManifestKeys)(nrsp->iface, buffer, buffer_bytes))
> NACL_ABI_SIZE_T_MAX) {
NaClLog(LOG_FATAL,
("ManifestListRpc: buffer size required is too large"
", %08"NACL_PRIdS"\n"),
size);
}
out_args[0]->u.count = (nacl_abi_size_t) size;
rpc->result = NACL_SRPC_RESULT_OK;
(*done_cls->Run)(done_cls);
}
static void NaClReverseServiceCreateProcessFunctorResultRpc(
struct NaClSrpcRpc *rpc,
struct NaClSrpcArg **in_args,
struct NaClSrpcArg **out_args,
struct NaClSrpcClosure *done_cls) {
struct NaClReverseService *nrsp =
(struct NaClReverseService *) rpc->channel->server_instance_data;
struct CreateProcessFunctorState functor_state;
UNREFERENCED_PARAMETER(in_args);
NaClLog(4,
"Entered NaClReverseServiceCreateProcessFunctorResultRpc: 0x%08"
NACL_PRIxPTR"\n",
(uintptr_t) nrsp);
functor_state.out_sock_addr = &out_args[0]->u.hval;
functor_state.out_app_addr = &out_args[1]->u.hval;
functor_state.out_pid = &out_args[2]->u.ival;
functor_state.cls = done_cls;
rpc->result = NACL_SRPC_RESULT_OK;
(*NACL_VTBL(NaClReverseInterface, nrsp->iface)->
CreateProcessFunctorResult)(nrsp->iface,
CreateProcessFunctor, &functor_state);
NaClLog(4, "Leaving NaClReverseServiceCreateProcessFunctorResultRpc\n");
}
static void NaClReverseServiceCreateProcessRpc(
struct NaClSrpcRpc *rpc,
struct NaClSrpcArg **in_args,
struct NaClSrpcArg **out_args,
struct NaClSrpcClosure *done_cls) {
struct NaClReverseService *nrsp =
(struct NaClReverseService *) rpc->channel->server_instance_data;
struct NaClDesc *sock_addr;
struct NaClDesc *app_addr;
int status;
UNREFERENCED_PARAMETER(in_args);
NaClLog(4,
"Entered NaClReverseServiceCreateProcessRpc: 0x%08"NACL_PRIxPTR"\n",
(uintptr_t) nrsp);
status = (*NACL_VTBL(NaClReverseInterface, nrsp->iface)->
CreateProcess)(nrsp->iface, &sock_addr, &app_addr);
out_args[0]->u.ival = status;
out_args[1]->u.hval = (0 == status)
? sock_addr
: (struct NaClDesc *) NaClDescInvalidMake();
out_args[2]->u.hval = (0 == status)
? app_addr
: (struct NaClDesc *) NaClDescInvalidMake();
NaClLog(4, "Leaving NaClReverseServiceCreateProcessRpc\n");
rpc->result = NACL_SRPC_RESULT_OK;
(*done_cls->Run)(done_cls);
}
int NaClAddrSpSquattingThreadIfCtor_protected(
struct NaClAddrSpSquattingThreadInterface *self,
void *factory_data,
NaClThreadIfStartFunction thread_fn_ptr,
void *thread_fn_data,
size_t thread_stack_size) {
NaClLog(3, "Entered NaClAddrSpSquattingThreadIfCtor_protected\n");
if (!NaClThreadInterfaceCtor_protected(
(struct NaClThreadInterface *) self,
NaClAddrSpSquattingThreadIfFactoryFunction,
factory_data, /* nap */
thread_fn_ptr,
thread_fn_data,
thread_stack_size)) {
NaClLog(3,
("NaClAddrSpSquattingThreadIfCtor_protected: placement base class"
" ctor failed\n"));
return 0;
}
self->nap = (struct NaClApp *) factory_data;
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClAddrSpSquattingThreadInterfaceVtbl;
NaClLog(3, "Leaving NaClAddrSpSquattingThreadIfCtor_protected\n");
return 1;
}
int NaClDescGetFileToken(struct NaClDesc *desc,
struct NaClFileToken *out_token) {
int32_t metadata_type;
uint32_t metadata_bytes;
metadata_bytes = (uint32_t) sizeof *out_token;
metadata_type = (*NACL_VTBL(NaClDesc, desc)->
GetMetadata)(desc, &metadata_bytes,
(uint8_t *) out_token);
if (NACL_DESC_METADATA_NONE_TYPE == metadata_type) {
NaClLog(4, "NaClDescGetFileToken: no meta data, cannot map\n");
return 0;
} else if (NACL_DESC_METADATA_FILE_TOKEN_TYPE != metadata_type) {
return 0;
} else if (metadata_bytes != (uint32_t) sizeof *out_token) {
/* there is supposed to be a file token, but wrong size? */
NaClLog(LOG_WARNING,
"NaClDescGetFileToken: purported file token present,"
" but token size is incorrect.\n");
return 0;
}
NaClLog(4,
"NaClDescGetFileToken: got token 0x%"NACL_PRIx64":%"NACL_PRIx64"\n",
out_token->hi, out_token->lo);
return 1;
}
static void NaClKernelServiceCreateProcessRpc(
struct NaClSrpcRpc *rpc,
struct NaClSrpcArg **in_args,
struct NaClSrpcArg **out_args,
struct NaClSrpcClosure *done_cls) {
struct NaClKernelService *nksp =
(struct NaClKernelService *) rpc->channel->server_instance_data;
int status;
struct NaClDesc *sock_addr = NULL;
struct NaClDesc *app_addr = NULL;
UNREFERENCED_PARAMETER(in_args);
NaClLog(4, "NaClKernelServiceCreateProcessRpc: creating process\n");
status = (*NACL_VTBL(NaClKernelService, nksp)->CreateProcess)(
nksp, &sock_addr, &app_addr);
out_args[0]->u.ival = status;
out_args[1]->u.hval = (0 == status)
? sock_addr
: (struct NaClDesc *) NaClDescInvalidMake();
out_args[2]->u.hval = (0 == status)
? app_addr
: (struct NaClDesc *) NaClDescInvalidMake();
NaClLog(4,
("NaClKernelServiceCreateProcessRpc: status %d, sock_addr"
" 0x08%"NACL_PRIxPTR", app_addr 0x%08"NACL_PRIxPTR"\n"),
status, (uintptr_t) sock_addr, (uintptr_t) app_addr);
rpc->result = NACL_SRPC_RESULT_OK;
(*done_cls->Run)(done_cls);
if (0 == status) {
NaClDescUnref(sock_addr);
NaClDescUnref(app_addr);
}
}
static ssize_t ImcRecvmsg(NaClSrpcMessageDesc desc,
NaClSrpcMessageHeader* header,
int flags) {
/* Quota management is not supported in trusted SRPC. */
return NACL_VTBL(NaClDesc, desc)->RecvMsg(
desc, header, flags, (struct NaClDescQuotaInterface *) NULL);
}
ssize_t NaClDescQuotaRead(struct NaClDesc *vself,
void *buf,
size_t len) {
struct NaClDescQuota *self = (struct NaClDescQuota *) vself;
return (*NACL_VTBL(NaClDesc, self->desc)->Read)(self->desc, buf, len);
}
ssize_t NaClDescQuotaGetdents(struct NaClDesc *vself,
void *dirp,
size_t count) {
struct NaClDescQuota *self = (struct NaClDescQuota *) vself;
return (*NACL_VTBL(NaClDesc, self->desc)->Getdents)(self->desc, dirp, count);
}
void NaClReverseServiceDtor(struct NaClRefCount *vself) {
struct NaClReverseService *self = (struct NaClReverseService *) vself;
if (0 != self->thread_count) {
NaClLog(LOG_FATAL,
"ReverseService dtor when thread count is nonzero\n");
}
self->thread_count = 0;
NaClRefCountUnref((struct NaClRefCount *) self->iface);
NaClCondVarDtor(&self->cv);
NaClMutexDtor(&self->mu);
NACL_VTBL(NaClRefCount, self) = (struct NaClRefCountVtbl *)
&kNaClSimpleRevServiceVtbl;
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
}
int NaClDescQuotaCtor(struct NaClDescQuota *self,
struct NaClDesc *desc,
uint8_t const *file_id,
struct NaClDescQuotaInterface *quota_interface) {
int rv;
if (!NaClDescCtor(&self->base)) {
NACL_VTBL(NaClDescQuota, self) = NULL;
return 0;
}
rv = NaClDescQuotaSubclassCtor(self, desc, file_id, quota_interface);
if (!rv) {
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
return 0;
}
return rv;
}
