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; }