void LoadBlob_SYMMETRIC_KEY(UINT64 *offset, BYTE *blob, TCPA_SYMMETRIC_KEY *key) { LoadBlob_UINT32(offset, key->algId, blob); LoadBlob_UINT16(offset, key->encScheme, blob); LoadBlob_UINT16(offset, key->size, blob); if (key->size > 0) { LoadBlob(offset, key->size, blob, key->data); } else { key->data = NULL; } }
int loadData(UINT64 *offset, TCSD_PACKET_TYPE data_type, void *data, int data_size, BYTE *blob) { switch (data_type) { case TCSD_PACKET_TYPE_BYTE: LoadBlob_BYTE(offset, *((BYTE *) (data)), blob); break; case TCSD_PACKET_TYPE_BOOL: LoadBlob_BOOL(offset, *((TSS_BOOL *) (data)), blob); break; case TCSD_PACKET_TYPE_UINT16: LoadBlob_UINT16(offset, *((UINT16 *) (data)), blob); break; case TCSD_PACKET_TYPE_UINT32: LoadBlob_UINT32(offset, *((UINT32 *) (data)), blob); break; case TCSD_PACKET_TYPE_UINT64: LoadBlob_UINT64(offset, *((UINT64 *) (data)), blob); break; case TCSD_PACKET_TYPE_PBYTE: LoadBlob(offset, data_size, blob, data); break; case TCSD_PACKET_TYPE_NONCE: LoadBlob(offset, sizeof(TCPA_NONCE), blob, ((TCPA_NONCE *)data)->nonce); break; case TCSD_PACKET_TYPE_DIGEST: LoadBlob(offset, sizeof(TCPA_DIGEST), blob, ((TCPA_DIGEST *)data)->digest); break; case TCSD_PACKET_TYPE_AUTH: LoadBlob_Auth_Special(offset, blob, ((TPM_AUTH *)data)); break; #ifdef TSS_BUILD_PS case TCSD_PACKET_TYPE_UUID: LoadBlob_UUID(offset, blob, *((TSS_UUID *)data)); break; case TCSD_PACKET_TYPE_KM_KEYINFO: LoadBlob_KM_KEYINFO(offset, blob, ((TSS_KM_KEYINFO *)data)); break; case TCSD_PACKET_TYPE_KM_KEYINFO2: LoadBlob_KM_KEYINFO2(offset, blob, ((TSS_KM_KEYINFO2 *)data)); break; case TCSD_PACKET_TYPE_LOADKEY_INFO: LoadBlob_LOADKEY_INFO(offset, blob, ((TCS_LOADKEY_INFO *)data)); break; #endif case TCSD_PACKET_TYPE_ENCAUTH: LoadBlob(offset, sizeof(TCPA_ENCAUTH), blob, ((TCPA_ENCAUTH *)data)->authdata); break; case TCSD_PACKET_TYPE_VERSION: LoadBlob_VERSION(offset, blob, ((TPM_VERSION *)data)); break; #ifdef TSS_BUILD_PCR_EVENTS case TCSD_PACKET_TYPE_PCR_EVENT: LoadBlob_PCR_EVENT(offset, blob, ((TSS_PCR_EVENT *)data)); break; #endif case TCSD_PACKET_TYPE_SECRET: LoadBlob(offset, sizeof(TCPA_SECRET), blob, ((TCPA_SECRET *)data)->authdata); break; default: LogError("TCSD packet type unknown! (0x%x)", data_type & 0xff); return TCSERR(TSS_E_INTERNAL_ERROR); } return TSS_SUCCESS; }
void * tcsd_thread_run(void *v) { struct tcsd_thread_data *data = (struct tcsd_thread_data *)v; BYTE buffer[TCSD_TXBUF_SIZE]; struct tcsd_packet_hdr *ret_buf = NULL; TSS_RESULT result; int sizeToSend, sent_total, sent; UINT64 offset; #ifndef TCSD_SINGLE_THREAD_DEBUG int rc; thread_signal_init(); #endif if ((data->buf_size = recv(data->sock, buffer, TCSD_TXBUF_SIZE, 0)) < 0) { LogError("Failed Receive: %s", strerror(errno)); goto done; } LogDebug("Rx'd packet"); data->buf = buffer; while (1) { sent_total = 0; if (data->buf_size > TCSD_TXBUF_SIZE) { LogError("Packet received from socket %d was too large (%u bytes)", data->sock, data->buf_size); goto done; } else if (data->buf_size < (int)((2 * sizeof(UINT32)) + sizeof(UINT16))) { LogError("Packet received from socket %d was too small (%u bytes)", data->sock, data->buf_size); goto done; } if ((result = getTCSDPacket(data, &ret_buf)) != TSS_SUCCESS) { /* something internal to the TCSD went wrong in preparing the packet * to return to the TSP. Use our already allocated buffer to return a * TSS_E_INTERNAL_ERROR return code to the TSP. In the non-error path, * these LoadBlob's are done in getTCSDPacket(). */ offset = 0; /* load result */ LoadBlob_UINT32(&offset, result, buffer); /* load packet size */ LoadBlob_UINT32(&offset, sizeof(struct tcsd_packet_hdr), buffer); /* load num parms */ LoadBlob_UINT16(&offset, 0, buffer); sizeToSend = sizeof(struct tcsd_packet_hdr); LogDebug("Sending 0x%X bytes back", sizeToSend); while (sent_total < sizeToSend) { if ((sent = send(data->sock, &data->buf[sent_total], sizeToSend - sent_total, 0)) < 0) { LogError("Packet send to TSP failed: send: %s. Thread exiting.", strerror(errno)); goto done; } sent_total += sent; } } else { sizeToSend = Decode_UINT32((BYTE *)&(ret_buf->packet_size)); LogDebug("Sending 0x%X bytes back", sizeToSend); while (sent_total < sizeToSend) { if ((sent = send(data->sock, &(((BYTE *)ret_buf)[sent_total]), sizeToSend - sent_total, 0)) < 0) { LogError("response to TSP failed: send: %s. Thread exiting.", strerror(errno)); free(ret_buf); ret_buf = NULL; goto done; } sent_total += sent; } free(ret_buf); ret_buf = NULL; } if (tm->shutdown) { LogDebug("Thread %zd exiting via shutdown signal!", THREAD_ID); break; } /* receive the next packet */ if ((data->buf_size = recv(data->sock, buffer, TCSD_TXBUF_SIZE, 0)) < 0) { LogError("TSP has closed its connection: %s. Thread exiting.", strerror(errno)); break; } else if (data->buf_size == 0) { LogDebug("The TSP has closed the socket's connection. Thread exiting."); break; } } done: /* Closing connection to TSP */ close(data->sock); data->sock = -1; data->buf = NULL; data->buf_size = -1; /* If the connection was not shut down cleanly, free TCS resources here */ if (data->context != NULL_TCS_HANDLE) { TCS_CloseContext_Internal(data->context); data->context = NULL_TCS_HANDLE; } #ifndef TCSD_SINGLE_THREAD_DEBUG MUTEX_LOCK(tm->lock); tm->num_active_threads--; /* if we're not in shutdown mode, then nobody is waiting to join this thread, so * detach it so that its resources are free at THREAD_EXIT() time. */ if (!tm->shutdown) { if ((rc = THREAD_DETACH(*(data->thread_id)))) { LogError("Thread detach failed (errno %d)." " Resources may not be properly released.", rc); } } free(data->hostname); data->hostname = NULL; data->thread_id = THREAD_NULL; MUTEX_UNLOCK(tm->lock); THREAD_EXIT(NULL); #else return NULL; #endif }