struct NaClDescInvalid const *NaClDescInvalidMake(void) {
NaClXMutexLock(mutex);
if (NULL == singleton) {
do {
/* Allocate an instance. */
singleton = (struct NaClDescInvalid *) malloc(sizeof(*singleton));
if (NULL == singleton) {
break;
}
/* Do the base class construction. */
if (!NaClDescCtor(&(singleton->base))) {
free(singleton);
singleton = NULL;
break;
}
/* Construct the derived class (simply set the vtbl). */
singleton->base.base.vtbl =
(struct NaClRefCountVtbl const *) &kNaClDescInvalidVtbl;
} while (0);
}
NaClXMutexUnlock(mutex);
/* If we reached this point and still have NULL == singleton there was an
* error in allocation or construction. Return NULL to indicate error.
*/
if (NULL == singleton) {
return NULL;
}
return (struct NaClDescInvalid *) NaClDescRef(&(singleton->base));
}
int NaClDescConnCapFdInternalize(
struct NaClDesc **out_desc,
struct NaClDescXferState *xfer,
struct NaClDescQuotaInterface *quota_interface) {
struct NaClDescConnCapFd *conn_cap;
UNREFERENCED_PARAMETER(quota_interface);
if (xfer->next_handle == xfer->handle_buffer_end) {
return -NACL_ABI_EIO;
}
conn_cap = malloc(sizeof(*conn_cap));
if (NULL == conn_cap) {
return -NACL_ABI_ENOMEM;
}
if (!NaClDescCtor(&conn_cap->base)) {
free(conn_cap);
return -NACL_ABI_ENOMEM;
}
conn_cap->base.base.vtbl =
(struct NaClRefCountVtbl const *) &kNaClDescConnCapFdVtbl;
conn_cap->connect_fd = *xfer->next_handle;
*xfer->next_handle++ = NACL_INVALID_HANDLE;
*out_desc = &conn_cap->base;
return 0;
}
int NaClDescNullCtor(struct NaClDescNull *self) {
if (!NaClDescCtor((struct NaClDesc *) self)) {
return 0;
}
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClDescNullVtbl;
return 1;
}
int NaClDescConnCapFdCtor(struct NaClDescConnCapFd *self,
NaClHandle endpt) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
self->connect_fd = endpt;
basep->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClDescConnCapFdVtbl;
return 1;
}
/*
* Takes ownership of hd, will close in Dtor.
*/
int NaClDescDirDescCtor(struct NaClDescDirDesc *self,
struct NaClHostDir *hd) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
self->hd = hd;
basep->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClDescDirDescVtbl;
return 1;
}
int NaClDescSyncSocketCtor(struct NaClDescSyncSocket *self,
NaClHandle h) {
int rv;
if (!NaClDescCtor(&self->base)) {
return 0;
}
rv = NaClDescSyncSocketSubclassCtor(self, h);
if (!rv) {
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
}
return rv;
}
int NaClDescSyncSocketCtor(struct NaClDescSyncSocket *self,
NaClHandle h) {
int retval;
retval = NaClDescCtor(&self->base);
if (!retval) {
return 0;
}
self->h = h;
self->base.vtbl = &kNaClDescSyncSocketVtbl;
return retval;
}
int NaClDescImcBoundDescCtor(struct NaClDescImcBoundDesc *self,
NaClHandle h) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
self->h = h;
basep->base.vtbl = (struct NaClRefCountVtbl const *)
&kNaClDescImcBoundDescVtbl;
return 1;
}
/*
* Takes ownership of hd, will close in Dtor.
*/
int NaClDescMutexCtor(struct NaClDescMutex *self) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
if (!NaClIntrMutexCtor(&self->mu)) {
(*basep->base.vtbl->Dtor)(&basep->base);
return 0;
}
basep->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClDescMutexVtbl;
return 1;
}
int NaClDescCondVarCtor(struct NaClDescCondVar *self) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
if (!NaClIntrCondVarCtor(&self->cv)) {
(*basep->base.vtbl->Dtor)(&basep->base);
return 0;
}
basep->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClDescCondVarVtbl;
return 1;
}
/*
* Takes ownership of hd, will close in Dtor.
*/
int NaClDescMutexCtor(struct NaClDescMutex *self) {
struct NaClDesc *basep = (struct NaClDesc *) self;
basep->vtbl = (struct NaClDescVtbl *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
if (!NaClIntrMutexCtor(&self->mu)) {
NaClDescDtor(basep);
return 0;
}
basep->vtbl = &kNaClDescMutexVtbl;
return 1;
}
/*
* Takes ownership of hd, will close in Dtor.
*/
int NaClDescIoDescCtor(struct NaClDescIoDesc *self,
struct NaClHostDesc *hd) {
struct NaClDesc *basep = (struct NaClDesc *) self;
int rv;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
rv = NaClDescIoDescSubclassCtor(self, hd);
if (!rv) {
(*NACL_VTBL(NaClRefCount, basep)->Dtor)((struct NaClRefCount *) basep);
}
return rv;
}
int NaClDescConnCapFdCtor(struct NaClDescConnCapFd *self,
NaClHandle endpt) {
struct NaClDesc *basep = (struct NaClDesc *) self;
int rv;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
rv = NaClDescConnCapFdSubclassCtor(self, endpt);
if (!rv) {
(*NACL_VTBL(NaClRefCount, basep)->Dtor)((struct NaClRefCount *) self);
}
return rv;
}
int NaClDescInternalizeCtor(struct NaClDesc *vself,
struct NaClDescXferState *xfer) {
int rv;
char *nxt;
rv = NaClDescCtor(vself);
if (0 == rv) {
return rv;
}
nxt = xfer->next_byte;
if (nxt + sizeof vself->flags > xfer->byte_buffer_end) {
rv = 0;
goto done;
}
memcpy(&vself->flags, nxt, sizeof vself->flags);
nxt += sizeof vself->flags;
if (0 == (NACL_DESC_FLAGS_HAS_METADATA & vself->flags)) {
xfer->next_byte = nxt;
rv = 1;
goto done;
}
if (nxt + sizeof vself->metadata_type + sizeof vself->metadata_num_bytes >
xfer->byte_buffer_end) {
rv = 0;
goto done;
}
memcpy(&vself->metadata_type, nxt, sizeof vself->metadata_type);
nxt += sizeof vself->metadata_type;
memcpy(&vself->metadata_num_bytes, nxt, sizeof vself->metadata_num_bytes);
nxt += sizeof vself->metadata_num_bytes;
if (nxt + vself->metadata_num_bytes > xfer->byte_buffer_end) {
rv = 0;
goto done;
}
if (NULL == (vself->metadata = malloc(vself->metadata_num_bytes))) {
rv = 0;
goto done;
}
memcpy(vself->metadata, nxt, vself->metadata_num_bytes);
nxt += vself->metadata_num_bytes;
xfer->next_byte = nxt;
rv = 1;
done:
if (!rv) {
(*NACL_VTBL(NaClRefCount, vself)->Dtor)((struct NaClRefCount *) vself);
}
return rv;
}
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;
}
int NaClDescRngCtor(struct NaClDescRng *self) {
if (!NaClDescCtor((struct NaClDesc *) self)) {
goto base_ctor_fail;
}
if (!NaClSecureRngCtor(&self->rng)) {
goto rng_ctor_fail;
}
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl *) &kNaClDescRngVtbl;
return 1;
/* failure cleanup */
rng_ctor_fail:
(*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
base_ctor_fail:
return 0;
}
int NaClDescImcConnectedDescCtor(struct NaClDescImcConnectedDesc *self,
NaClHandle h) {
struct NaClDesc *basep = (struct NaClDesc *) self;
int rv;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
rv = NaClDescImcConnectedDescSubclassCtor(self, h);
if (!rv) {
(*NACL_VTBL(NaClRefCount, basep)->Dtor)((struct NaClRefCount *) basep);
}
return rv;
}
int NaClDescPostMessageCtor(struct NaClDescPostMessage *self,
struct NaClRuntimeHostInterface *runtime_host) {
NaClLog(4, "Entered NaClDescPostMessageCtor\n");
NACL_VTBL(NaClRefCount, self) = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(&self->base)) {
NaClLog(4, "Leaving NaClDescPostMessageCtor: failed\n");
return 0;
}
self->runtime_host = (struct NaClRuntimeHostInterface *)
NaClRefCountRef((struct NaClRefCount *) runtime_host);
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl const *) &kNaClDescPostMessageVtbl;
NaClLog(4, " Write vfptr = %"NACL_PRIxPTR"\n",
(uintptr_t) NACL_VTBL(NaClDesc, self)->Write);
NaClLog(4, "Leaving NaClDescPostMessageCtor: success\n");
return 1;
}
int NaClDescPostMessageCtor(struct NaClDescPostMessage *self,
struct NaClApp *nap) {
NaClLog(4, "Entered NaClDescPostMessageCtor\n");
NACL_VTBL(NaClRefCount, self) = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(&self->base)) {
NaClLog(4, "Leaving NaClDescPostMessageCtor: failed\n");
return 0;
}
self->nap = nap;
self->error = 0;
NACL_VTBL(NaClRefCount, self) =
(struct NaClRefCountVtbl const *) &kNaClDescPostMessageVtbl;
NaClLog(4, " Write vfptr = %"NACL_PRIxPTR"\n",
(uintptr_t) NACL_VTBL(NaClDesc, self)->Write);
NaClLog(4, "Leaving NaClDescPostMessageCtor: success\n");
return 1;
}
int NaClDescConnCapCtor(struct NaClDescConnCap *self,
struct NaClSocketAddress const *nsap) {
struct NaClDesc *basep = (struct NaClDesc *) self;
int rv;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
rv = NaClDescConnCapSubclassCtor(self, nsap);
if (!rv) {
/* NaClDescConnCap construction failed, still a NaClDesc object */
(*NACL_VTBL(NaClRefCount, basep)->Dtor)((struct NaClRefCount *) basep);
/* not-an-object; caller frees */
}
return rv;
}
int NaClDescImcShmCtor(struct NaClDescImcShm *self,
NaClHandle h,
nacl_off64_t size) {
struct NaClDesc *basep = (struct NaClDesc *) self;
int rv;
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (!NaClDescCtor(basep)) {
return 0;
}
rv = NaClDescImcShmSubclassCtor(self, h, size);
if (!rv) {
/* NaClDescImcShm construction failed, still a NaClDesc object */
(*NACL_VTBL(NaClRefCount, basep)->Dtor)((struct NaClRefCount *) basep);
}
(*NACL_VTBL(NaClDesc, basep)->SetFlags)(basep, NACL_ABI_O_RDWR);
return 1;
}
struct NaClDesc *NaClDescMakeCustomDesc(
void *handle, const struct NaClDescCustomFuncs *funcs) {
struct NaClDescCustom *desc = malloc(sizeof *desc);
if (NULL == desc) {
return NULL;
}
if (!NaClDescCtor(&desc->base)) {
free(desc);
return NULL;
}
/* For simplicity, all the callbacks are currently required. */
DCHECK(funcs->Destroy != NULL);
DCHECK(funcs->SendMsg != NULL);
DCHECK(funcs->RecvMsg != NULL);
desc->handle = handle;
desc->funcs = *funcs;
desc->base.base.vtbl = (const struct NaClRefCountVtbl *) &kNaClDescCustomVtbl;
return &desc->base;
}
int NaClDescImcShmCtor(struct NaClDescImcShm *self,
NaClHandle h,
nacl_off64_t size) {
struct NaClDesc *basep = (struct NaClDesc *) self;
/*
* off_t is signed, but size_t are not; historically size_t is for
* sizeof and similar, and off_t is also used for stat structure
* st_size member. This runtime test detects large object sizes
* that are silently converted to negative values.
*/
basep->base.vtbl = (struct NaClRefCountVtbl const *) NULL;
if (size < 0 || SIZE_T_MAX < (uint64_t) size) {
return 0;
}
if (!NaClDescCtor(basep)) {
return 0;
}
self->h = h;
self->size = size;
basep->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClDescImcShmVtbl;
return 1;
}
