int NaClDescConnCapFdInternalize(
struct NaClDesc **out_desc,
struct NaClDescXferState *xfer) {
struct NaClDescConnCapFd *conn_cap;
int rv;
conn_cap = malloc(sizeof(*conn_cap));
if (NULL == conn_cap) {
return -NACL_ABI_ENOMEM;
}
if (!NaClDescInternalizeCtor(&conn_cap->base, xfer)) {
free(conn_cap);
conn_cap = NULL;
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (xfer->next_handle == xfer->handle_buffer_end) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
rv = NaClDescConnCapFdSubclassCtor(conn_cap, *xfer->next_handle);
if (!rv) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
*xfer->next_handle++ = NACL_INVALID_HANDLE;
*out_desc = &conn_cap->base;
rv = 0;
cleanup:
if (rv < 0) {
NaClDescSafeUnref((struct NaClDesc *) conn_cap);
}
return rv;
}
int NaClDescImcShmInternalize(struct NaClDesc **out_desc,
struct NaClDescXferState *xfer,
struct NaClDescQuotaInterface *quota_interface) {
int rv;
struct NaClDescImcShm *ndisp;
NaClHandle h;
nacl_off64_t hsize;
UNREFERENCED_PARAMETER(quota_interface);
rv = -NACL_ABI_EIO;
ndisp = malloc(sizeof *ndisp);
if (NULL == ndisp) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (!NaClDescInternalizeCtor((struct NaClDesc *) ndisp, xfer)) {
free(ndisp);
ndisp = NULL;
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (xfer->next_handle == xfer->handle_buffer_end) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
if (xfer->next_byte + sizeof ndisp->size > xfer->byte_buffer_end) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
h = *xfer->next_handle;
*xfer->next_handle++ = NACL_INVALID_HANDLE;
memcpy(&hsize, xfer->next_byte, sizeof hsize);
xfer->next_byte += sizeof hsize;
if (!NaClDescImcShmSubclassCtor(ndisp, h, hsize)) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
*out_desc = (struct NaClDesc *) ndisp;
rv = 0;
cleanup:
if (rv < 0) {
NaClDescSafeUnref((struct NaClDesc *) ndisp);
}
return rv;
}
int NaClDescXferableDataDescInternalize(
struct NaClDesc **baseptr,
struct NaClDescXferState *xfer,
struct NaClDescQuotaInterface *quota_interface) {
int rv;
struct NaClDescXferableDataDesc *ndxdp;
UNREFERENCED_PARAMETER(quota_interface);
NaClLog(4, "Entered NaClDescXferableDataDescInternalize\n");
ndxdp = malloc(sizeof *ndxdp);
if (NULL == ndxdp) {
NaClLog(LOG_ERROR,
"NaClXferableDataDescInternalize: no memory\n");
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
rv = NaClDescInternalizeCtor((struct NaClDesc *) ndxdp, xfer);
if (!rv) {
free(ndxdp);
ndxdp = NULL;
goto cleanup;
}
if (xfer->next_handle == xfer->handle_buffer_end) {
NaClLog(LOG_ERROR,
("NaClXferableDataDescInternalize: no descriptor"
" left in xfer state\n"));
rv = -NACL_ABI_EIO;
goto cleanup;
}
if (!NaClDescXferableDataDescSubclassesCtor(ndxdp,
*xfer->next_handle)) {
NaClLog(LOG_ERROR,
"NaClXferableDataDescInternalize: descriptor ctor error\n");
rv = -NACL_ABI_EIO;
goto cleanup;
}
*xfer->next_handle++ = NACL_INVALID_HANDLE;
*baseptr = (struct NaClDesc *) ndxdp;
rv = 0;
cleanup:
if (rv < 0) {
NaClDescSafeUnref((struct NaClDesc *) ndxdp);
}
return rv;
}
int NaClDescConnCapInternalize(struct NaClDesc **out_desc,
struct NaClDescXferState *xfer,
struct NaClDescQuotaInterface *quota_interface) {
int rv;
struct NaClSocketAddress nsa;
struct NaClDescConnCap *ndccp;
UNREFERENCED_PARAMETER(quota_interface);
rv = -NACL_ABI_EIO; /* catch-all */
ndccp = malloc(sizeof *ndccp);
if (NULL == ndccp) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (!NaClDescInternalizeCtor((struct NaClDesc *) ndccp, xfer)) {
free(ndccp);
ndccp = NULL;
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (xfer->next_byte + NACL_PATH_MAX > xfer->byte_buffer_end) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
memcpy(nsa.path, xfer->next_byte, NACL_PATH_MAX);
if (!NaClDescConnCapSubclassCtor(ndccp, &nsa)) {
rv = -NACL_ABI_EIO;
goto cleanup;
}
*out_desc = (struct NaClDesc *) ndccp;
rv = 0;
xfer->next_byte += NACL_PATH_MAX;
cleanup:
if (rv < 0) {
NaClDescSafeUnref((struct NaClDesc *) ndccp);
}
return rv;
}
/* set *out_desc to struct NaClDescIo * output */
int NaClDescIoInternalize(struct NaClDesc **out_desc,
struct NaClDescXferState *xfer,
struct NaClDescQuotaInterface *quota_interface) {
int rv;
NaClHandle h;
int d;
int flags;
struct NaClHostDesc *nhdp;
struct NaClDescIoDesc *ndidp;
UNREFERENCED_PARAMETER(quota_interface);
rv = -NACL_ABI_EIO; /* catch-all */
h = NACL_INVALID_HANDLE;
nhdp = NULL;
ndidp = NULL;
nhdp = malloc(sizeof *nhdp);
if (NULL == nhdp) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
ndidp = malloc(sizeof *ndidp);
if (!ndidp) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (!NaClDescInternalizeCtor((struct NaClDesc *) ndidp, xfer)) {
rv = -NACL_ABI_ENOMEM;
goto cleanup;
}
if (xfer->next_handle == xfer->handle_buffer_end ||
xfer->next_byte + sizeof ndidp->hd->flags > xfer->byte_buffer_end) {
rv = -NACL_ABI_EIO;
goto cleanup_ndidp_dtor;
}
NACL_COMPILE_TIME_ASSERT(sizeof flags == sizeof(ndidp->hd->flags));
memcpy(&flags, xfer->next_byte, sizeof flags);
xfer->next_byte += sizeof flags;
h = *xfer->next_handle;
*xfer->next_handle++ = NACL_INVALID_HANDLE;
#if NACL_WINDOWS
if (-1 == (d = _open_osfhandle((intptr_t) h, _O_RDWR | _O_BINARY))) {
rv = -NACL_ABI_EIO;
goto cleanup_ndidp_dtor;
}
#else
d = h;
#endif
/*
* We mark it as read/write, but don't really know for sure until we
* try to make those syscalls (in which case we'd get EBADF).
*/
if ((rv = NaClHostDescPosixTake(nhdp, d, flags)) < 0) {
goto cleanup_ndidp_dtor;
}
h = NACL_INVALID_HANDLE; /* nhdp took ownership of h */
if (!NaClDescIoDescSubclassCtor(ndidp, nhdp)) {
rv = -NACL_ABI_ENOMEM;
goto cleanup_nhdp_dtor;
}
/*
* ndidp took ownership of nhdp, now give ownership of ndidp to caller.
*/
*out_desc = (struct NaClDesc *) ndidp;
rv = 0;
cleanup_nhdp_dtor:
if (rv < 0) {
if (0 != NaClHostDescClose(nhdp)) {
NaClLog(LOG_FATAL, "NaClDescIoInternalize: NaClHostDescClose failed\n");
}
}
cleanup_ndidp_dtor:
if (rv < 0) {
NaClDescSafeUnref((struct NaClDesc *) ndidp);
ndidp = NULL;
}
cleanup:
if (rv < 0) {
free(nhdp);
free(ndidp);
if (NACL_INVALID_HANDLE != h) {
(void) NaClClose(h);
}
}
return rv;
}
