/** * Read the CRT protocol header returning the length of the data field */ static int readHeader(int sd, void *buf) { char *p = (char *) buf; int len; if ((len = recvBytes(sd, buf, CERT_HEADER_LEN)) <= 0) return len; if (p[0] != 'C' || p[1] != 'R' || p[2] != 'T') { logError("Bad MAGIC received in header\n"); return -2; } if (p[3] != '0') { logError("Unknown protocol/request received in header\n"); return -2; } certHeader_t *req = (certHeader_t *) buf; req->length = htonl(req->length); if (req->length == 0) { logWarn("Received header with data length = %d\n", req->length); return 0; } return req->length; }
void putFile(int sock, char * filename) { printf("Putting in file %s\n", filename); char recvbuf[1024]; memset(recvbuf, 0, 1024); // create a file to write the contents into FILE * fp = fopen(filename, "w"); if (fp == NULL) { perror("fopen"); exit(EXIT_FAILURE); } // continually read the bytes and write the data while(1) { ssize_t ret = 0; memset(recvbuf, 0, 1024); ret = recvBytes(sock, recvbuf, 1024); if (ret == 0) { // server closed connection, close the file fclose(fp); return; } fwrite(recvbuf, 1, ret, fp); } }
/** * Method to validate the password sent to server from the client */ int checkPass(int sock) { char recvbuf[1024]; memset(recvbuf, 0, 1024); recvBytes(sock, recvbuf, strlen(password)); printf("Password received: %s\n", recvbuf); // check if it is equal to the password if(strcmp(recvbuf, password) == 0) { return 1; } else { return -1; } }
static TSS2_RC tctiRecvBytes( TSS2_TCTI_CONTEXT *tctiContext, SOCKET sock, unsigned char *data, int len ) { TSS2_RC result = 0; result = recvBytes( sock, data, len); if ( (INT32)result == SOCKET_ERROR) { TCTI_LOG( tctiContext, NO_PREFIX, "In recvBytes, recv failed (socket: 0x%x) with error: %d\n", sock, WSAGetLastError() ); return TSS2_TCTI_RC_IO_ERROR; } #ifdef DEBUG_SOCKETS TCTI_LOG( tctiContext, NO_PREFIX, "Receive Bytes from socket #0x%x: \n", sock ); TCTI_LOG_BUFFER( tctiContext, NO_PREFIX, data, len ); #endif return TSS2_RC_SUCCESS; }
static int client() { int sd = ipConnectPeer(arg.host, arg.port, 3); int filenameLen = strlen(arg.url); int reqLen = CERT_HEADER_LEN + filenameLen; certHeader_t *req = (certHeader_t *) malloc(reqLen); if (req == NULL) dieError("%s.malloc\n", __func__); req->id[0] = 'C'; req->id[1] = 'R'; req->id[2] = 'T'; req->id[3] = '0'; req->length = htonl(filenameLen); memcpy(&req->data[0], arg.url, filenameLen); logNorm("Requesting certificate '%s' (data len = %d)\n", arg.url, filenameLen); int len = ipsend(sd, req, reqLen); free(req); if (len < 0) return len; // Read the response char buf[1024]; if ((len = readHeader(sd, buf)) < 0) return len; if (len == 0) { logError("Received error response (certificate not found?)\n"); return -2; } void *certBuf = malloc(len); if (certBuf == NULL) dieError("%s.malloc\n", __func__); // Read the certificate int res; logNorm("Reading certificate of %d bytes\n", len); if ((res = recvBytes(sd, certBuf, len)) < 0) return res; hexdump(certBuf, 16, 16); close(sd); return 0; }
static int processRequest(int sd) { char buf[1024]; int len; if ((len = readHeader(sd, buf)) < 0) return len; if (len == 0) { logWarn("File not found, sending zero response\n", len); ipsend(sd, &idDefault, CERT_HEADER_LEN); return 0; } logNorm("Received header. Receiving data of length = %d\n", len); certHeader_t *req = (certHeader_t *) buf; if ((len = recvBytes(sd, &req->data, len)) <= 0) return len; char *filename = &req->data[0]; filename[len] = 0; char *fileBuf; logNorm("Reading certificate file '%s'\n", filename); if ((len = readFile(filename, &fileBuf)) < 0) return len; int rspLen = CERT_HEADER_LEN + len; certHeader_t *rsp = (certHeader_t *) malloc(rspLen); if (rsp == NULL) dieError("%s.malloc\n", __func__); memcpy(&rsp->id, idDefault, 4); rsp->length = htonl(len); memcpy(&rsp->data, fileBuf, len); hexdump(&rsp->data, 16, 16); logNorm("Sending certificate of size %d bytes\n", len); len = ipsend(sd, rsp, rspLen); free(fileBuf); free(rsp); return len; }
/** Receive a raw string (not encoded by msgpack). * This IO call blocks. * We pass the lua_State to avoid mixing thread contexts. */ LuaStackSize lk::Socket::recv(lua_State *L) { if (lua_isnumber(L, 3)) { setRecvTimeout(lua_tonumber(L, 3)); } if (lua_isnumber(L, 2)) { // <self> <num_bytes> [<timeout>] return recvBytes(L, lua_tonumber(L, 2)); } else if (lua_isstring(L, 2)) { // <self> <mode> [<timeout>] const char *mode = lua_tostring(L, 2); if (mode[0] == '*' && mode[1] == 'a') { return recvAll(L); } else if (mode[0] == '*' && mode[1] == 'l') { return recvLine(L); } else { throw dub::Exception("Bad mode to recv (should be '*a' or '*l' but found '%s')", mode); } } // receive a single line (not returning \r or \n). return recvLine(L); return 1; }
void receiveFile(int connfd) { char recvBuf[BUF_SIZE]; int bytes; uint32_t fileSize, remaining, remainLastUpdate; char *fileName; FILE *file; time_t last, current, start; // Receive size bytes = 4; if (recvBytes(connfd, recvBuf, &bytes) != 0) exit(1); memcpy(&fileSize, recvBuf, 4); fileSize = ntohl(fileSize); // Receive name bytes = FNAME_LEN; if (recvBytes(connfd, recvBuf, &bytes) != 0) exit(1); fileName = malloc(strlen(recvBuf) + strlen(OUTPUT_DIR) + 2); // Prepend directory name strcpy(fileName, OUTPUT_DIR); strcat(fileName, "/"); strcat(fileName, recvBuf); printf("ftps: Receiving file '%s' of size %u\n", fileName, fileSize); // Open file if ((file = fopen(fileName, "wb")) == NULL) { perror("ftps: Couldn't open file"); exit(1); } // Receive and write file remainLastUpdate = remaining = fileSize; start = last = time(NULL); while (remaining > 0) { if ((bytes = RECV(connfd, recvBuf, (remaining < BUF_SIZE) ? remaining : BUF_SIZE, 0)) == -1) { perror("ftps: recv"); exit(1); } if (bytes == 0) { fprintf(stderr, "ftps: Connection lost.\n"); exit(2); } remaining -= bytes; // Display info only once per second current = time(NULL); if (current >= last + 1) { printf("ftps: Received %.02f KB (%.02f KB/s)...\n", (fileSize-remainLastUpdate)/1000.0, ((remainLastUpdate-remaining)/1000.0)/difftime(current, last)); last = current; remainLastUpdate = remaining; } // Write to file if (fwrite(recvBuf, 1, bytes, file) != bytes) { fprintf(stderr, "ftps: File write error!\n"); exit(1); } } // Show stats current = time(NULL); printf("ftps: Received %.02f KB (average %.02f KB/s)...\n", fileSize/1000.0, (fileSize/1000.0)/difftime(current, start)); fflush(file); fclose(file); printf("ftps: Done\n"); }
TSS2_RC SocketReceiveTpmResponse( TSS2_TCTI_CONTEXT *tctiContext, /* in */ size_t *response_size, /* out */ unsigned char *response_buffer, /* in */ int32_t timeout ) { UINT32 trash; size_t responseSize = 0; TSS2_RC rval = TSS2_RC_SUCCESS; fd_set readFds; struct timeval tv, *tvPtr; int32_t timeoutMsecs = timeout % 1000; int iResult; if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED ) { #ifdef DEBUG (*printfFunction)( rmDebugPrefix, "Response Received: " ); #endif #ifdef DEBUG_SOCKETS (*printfFunction)( rmDebugPrefix, "from socket #0x%x:\n", TCTI_CONTEXT_INTEL->tpmSock ); #endif } if( *response_size > 0 ) { if( timeout == TSS2_TCTI_TIMEOUT_BLOCK ) { tvPtr = 0; } else { tv.tv_sec = timeout / 1000; tv.tv_usec = timeoutMsecs * 1000; tvPtr = &tv; } FD_ZERO( &readFds ); FD_SET( TCTI_CONTEXT_INTEL->tpmSock, &readFds ); iResult = select( TCTI_CONTEXT_INTEL->tpmSock+1, &readFds, 0, 0, tvPtr ); if( iResult == 0 ) { (*printfFunction)(NO_PREFIX, "select failed due to timeout, socket #: 0x%x\n", TCTI_CONTEXT_INTEL->tpmSock ); rval = TSS2_TCTI_RC_TRY_AGAIN; goto retSocketReceiveTpmResponse; } else if( iResult == SOCKET_ERROR ) { (*printfFunction)(NO_PREFIX, "select failed with socket error: %d\n", WSAGetLastError() ); rval = TSS2_TCTI_RC_IO_ERROR; goto retSocketReceiveTpmResponse; } else if ( iResult != 1 ) { (*printfFunction)(NO_PREFIX, "select failed, read the wrong # of bytes: %d\n", iResult ); rval = TSS2_TCTI_RC_IO_ERROR; goto retSocketReceiveTpmResponse; } // Receive the size of the response. recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)&responseSize, 4 ); responseSize = CHANGE_ENDIAN_DWORD( responseSize ); // Receive the TPM response. recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)response_buffer, responseSize ); #ifdef DEBUG if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED ) { DEBUG_PRINT_BUFFER( response_buffer, responseSize ); } #endif // Receive the appended four bytes of 0's recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)&trash, 4 ); } if( responseSize < *response_size ) { *response_size = responseSize; } ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.commandSent = 0; // Turn cancel off. rval = (TSS2_RC)PlatformCommand( tctiContext, MS_SIM_CANCEL_OFF ); if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED ) { // (*printfFunction)(NO_PREFIX, "%s sent cancel OFF command:\n", interfaceName ); } retSocketReceiveTpmResponse: return rval; }
void afLib::checkInterrupt(void) { int result; if (_interrupts_pending > 0) { //_theLog->print("_interrupts_pending: "); _theLog->println(_interrupts_pending); switch (_state) { case STATE_IDLE: if (_writeCmd != NULL) { // Include 2 bytes for length _bytesToSend = _writeCmd->getSize() + 2; } else { _bytesToSend = 0; } _state = STATE_STATUS_SYNC; printState(_state); return; case STATE_STATUS_SYNC: _txStatus->setAck(false); _txStatus->setBytesToSend(_bytesToSend); _txStatus->setBytesToRecv(0); result = exchangeStatus(_txStatus, _rxStatus); if (result == 0 && _rxStatus->isValid() && inSync(_txStatus, _rxStatus)) { _state = STATE_STATUS_ACK; if (_txStatus->getBytesToSend() == 0 && _rxStatus->getBytesToRecv() > 0) { _bytesToRecv = _rxStatus->getBytesToRecv(); } } else { // Try resending the preamble _state = STATE_STATUS_SYNC; _theLog->println("Collision"); // _txStatus->dumpBytes(); // _rxStatus->dumpBytes(); } printState(_state); break; case STATE_STATUS_ACK: _txStatus->setAck(true); _txStatus->setBytesToRecv(_rxStatus->getBytesToRecv()); _bytesToRecv = _rxStatus->getBytesToRecv(); result = writeStatus(_txStatus); if (result != 0) { _state = STATE_STATUS_SYNC; printState(_state); break; } if (_bytesToSend > 0) { _writeBufferLen = (uint16_t) _writeCmd->getSize(); _writeBuffer = new uint8_t[_bytesToSend]; memcpy(_writeBuffer, (uint8_t * ) & _writeBufferLen, 2); _writeCmd->getBytes(&_writeBuffer[2]); _state = STATE_SEND_BYTES; } else if (_bytesToRecv > 0) { _state = STATE_RECV_BYTES; } else { _state = STATE_CMD_COMPLETE; } printState(_state); break; case STATE_SEND_BYTES: // _theLog->print("send bytes: "); _theLog->println(_bytesToSend); sendBytes(); if (_bytesToSend == 0) { _writeBufferLen = 0; delete (_writeBuffer); _writeBuffer = NULL; _state = STATE_CMD_COMPLETE; printState(_state); } break; case STATE_RECV_BYTES: // _theLog->print("receive bytes: "); _theLog->println(_bytesToRecv); recvBytes(); if (_bytesToRecv == 0) { _state = STATE_CMD_COMPLETE; printState(_state); _readCmd = new Command(_theLog,_readBufferLen, &_readBuffer[2]); delete (_readBuffer); _readBuffer = NULL; } break; case STATE_CMD_COMPLETE: _state = STATE_IDLE; printState(_state); if (_readCmd != NULL) { byte *val = new byte[_readCmd->getValueLen()]; _readCmd->getValue(val); switch (_readCmd->getCommand()) { case MSG_TYPE_SET: _onAttrSet(_readCmd->getReqId(), _readCmd->getAttrId(), _readCmd->getValueLen(), val); break; case MSG_TYPE_UPDATE: if (_readCmd->getAttrId() == _outstandingSetGetAttrId) { _outstandingSetGetAttrId = 0; } _onAttrSetComplete(_readCmd->getReqId(), _readCmd->getAttrId(), _readCmd->getValueLen(), val); break; default: break; } delete (val); delete (_readCmd); _readCmdOffset = 0; _readCmd = NULL; } if (_writeCmd != NULL) { // Fake a callback here for MCU attributes as we don't get one from the module. if (_writeCmd->getCommand() == MSG_TYPE_UPDATE && IS_MCU_ATTR(_writeCmd->getAttrId())) { _onAttrSetComplete(_writeCmd->getReqId(), _writeCmd->getAttrId(), _writeCmd->getValueLen(), _writeCmd->getValueP()); } delete (_writeCmd); _writeCmdOffset = 0; _writeCmd = NULL; } break; } updateIntsPending(-1); } }
int main(int argc, char* argv[]) { // args should only be the port number and the name // of the program running if (argc != 2) { printf("Usage Error - provide port number\n"); exit(1); } char *port = argv[1]; // create the ./files dir createSubdir(); // getaddrinfo(): network address and service translation: struct addrinfo *socketaddrinfo = example_getaddrinfo(NULL, port); // socket(): create an endpoint for communication int sock = example_socket(socketaddrinfo); example_setsockopt(sock); example_bind(sock, socketaddrinfo); example_listen(sock, 128); freeaddrinfo(socketaddrinfo); // done with socketaddrinfo //printf("Press Ctrl+C to exit server.\n"); //printf("Run a web browser on the same computer as you run the server and point it to:\n"); //printf("http://127.0.0.1:%s\n", port); while(1) { printf("Waiting for connections...\n"); // Get a socket for a particular incoming connection. int newsock = accept(sock, NULL, NULL); if(newsock == -1) { perror("accept(): "); continue; // try again if accept failed. } printf("Client connected\n"); // Check the password of the client if (checkPass(newsock) == -1) { printf("Incorrect password - Connection aborted\n"); closeSock(newsock); continue; } else { printf("Password accepted - Continuing connection\n"); } sendBytes(newsock, "You connected!\n", strlen("You connected!\n")); char cmd[1024]; memset(cmd, 0, 1024); recvBytes(newsock, cmd, 1024); printf("Received command: %s\n", cmd); if (strcmp(cmd, "list") == 0) { sendBytes(newsock, "File listing:\n", strlen("File listing:\n")); // Scan the dirextory and send the file list sendList(newsock); continue; } if (strcmp(cmd, "get") == 0) { char retBuf[1024]; memset(retBuf, 0, 1024); // Read the name of the file recvBytes(newsock, retBuf, 1024); // Check if the file exists and send it getFile(newsock, retBuf); continue; } if (strcmp(cmd, "put") == 0) { char retBuf[1024]; memset(retBuf, 0, 1024); // Read the name of the file getLine(newsock, retBuf); // Check if the file exists and send it putFile(newsock, retBuf); continue; } // char http_body[] = "hello world"; // char http_headers[1024]; // snprintf(http_headers, 1024, // "HTTP/1.0 200 OK\r\n" // "Content-Length: %zu\r\n" // "Content-Type: text/html\r\n\r\n", // strlen(http_body)); // should check return value /* Note: send() does not guarantee that it will send all of * the data that we ask it too. To reliably send data, we * should inspect the return value from send() and then call * send() again on any bytes did not get sent. */ // Send the HTTP headers //if(send(newsock, http_headers, strlen(http_headers), 0) == -1) //{ // perror("send"); // close(newsock); // exit(EXIT_FAILURE); //} //// Send the HTTP body //if(send(newsock, http_body, strlen(http_body), 0) == -1) //{ // perror("send"); // close(newsock); // exit(EXIT_FAILURE); //} /* shutdown() (see "man 2 shutdown") can be used before close(). It allows you to partially close a socket (i.e., indicate that we are done sending data but still could receive). This could allow us to signal to a peer that we are done sending data while still allowing us to receive data. SHUT_RD will disallow reads from the socket, SHUT_WR will disallow writes, and SHUT_RDWR will disallow read and write. Also, unlike close(), shutdown() will affect all processes that are sharing the socket---while close() only affects the process that calls it. */ #if 0 if(shutdown(newsock, SHUT_RDWR) == -1) { perror("shutdown"); close(newsock); exit(EXIT_FAILURE); } #endif closeSock(newsock); } }
TSS2_RC SocketReceiveTpmResponse( TSS2_TCTI_CONTEXT *tctiContext, /* in */ size_t *response_size, /* out */ unsigned char *response_buffer, /* in */ int32_t timeout ) { UINT32 trash; TSS2_RC rval = TSS2_RC_SUCCESS; fd_set readFds; struct timeval tv, *tvPtr; int32_t timeoutMsecs = timeout % 1000; int iResult; unsigned char responseSizeDelta = 0; rval = CommonReceiveChecks( tctiContext, response_size, response_buffer ); if( rval != TSS2_RC_SUCCESS ) { goto retSocketReceiveTpmResponse; } if( timeout == TSS2_TCTI_TIMEOUT_BLOCK ) { tvPtr = 0; } else { tv.tv_sec = timeout / 1000; tv.tv_usec = timeoutMsecs * 1000; tvPtr = &tv; } FD_ZERO( &readFds ); FD_SET( TCTI_CONTEXT_INTEL->tpmSock, &readFds ); iResult = select( TCTI_CONTEXT_INTEL->tpmSock+1, &readFds, 0, 0, tvPtr ); if( iResult == 0 ) { (*printfFunction)(NO_PREFIX, "select failed due to timeout, socket #: 0x%x\n", TCTI_CONTEXT_INTEL->tpmSock ); rval = TSS2_TCTI_RC_TRY_AGAIN; goto retSocketReceiveTpmResponse; } else if( iResult == SOCKET_ERROR ) { (*printfFunction)(NO_PREFIX, "select failed with socket error: %d\n", WSAGetLastError() ); rval = TSS2_TCTI_RC_IO_ERROR; goto retSocketReceiveTpmResponse; } else if ( iResult != 1 ) { (*printfFunction)(NO_PREFIX, "select failed, read the wrong # of bytes: %d\n", iResult ); rval = TSS2_TCTI_RC_IO_ERROR; goto retSocketReceiveTpmResponse; } if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.protocolResponseSizeReceived != 1 ) { // Receive the size of the response. rval = recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)& (((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize ), 4 ); if( rval != TSS2_RC_SUCCESS ) goto retSocketReceiveTpmResponse; ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize = CHANGE_ENDIAN_DWORD( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize ); ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.protocolResponseSizeReceived = 1; } if( response_buffer == NULL ) { // In this case, just return the size *response_size = ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize; ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.protocolResponseSizeReceived = 1; goto retSocketReceiveTpmResponse; } if( *response_size < ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize ) { *response_size = ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize; rval = TSS2_TCTI_RC_INSUFFICIENT_BUFFER; // If possible, receive tag from TPM. if( *response_size >= sizeof( TPM_ST ) && ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.tagReceived == 0 ) { if( TSS2_RC_SUCCESS != recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)&( ( (TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->tag ), 2 ) ) { goto retSocketReceiveTpmResponse; } else { ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.tagReceived = 1; } } // If possible, receive response size from TPM if( *response_size >= ( sizeof( TPM_ST ) + sizeof( TPM_RC ) ) && ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.responseSizeReceived == 0 ) { if( TSS2_RC_SUCCESS != recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)&( ( (TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->responseSize ), 4 ) ) { goto retSocketReceiveTpmResponse; } else { ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize = CHANGE_ENDIAN_DWORD( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize ); ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.responseSizeReceived = 1; } } } else { if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED && ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize > 0 ) { #ifdef DEBUG (*printfFunction)( rmDebugPrefix, "Response Received: " ); #endif #ifdef DEBUG_SOCKETS (*printfFunction)( rmDebugPrefix, "from socket #0x%x:\n", TCTI_CONTEXT_INTEL->tpmSock ); #endif } if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.tagReceived == 1 ) { *(TPM_ST *)response_buffer = ( (TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->tag; responseSizeDelta += sizeof( TPM_ST ); response_buffer += sizeof( TPM_ST ); } if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.responseSizeReceived == 1 ) { *(TPM_RC *)response_buffer = CHANGE_ENDIAN_DWORD( ( (TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->responseSize ); responseSizeDelta += sizeof( TPM_RC ); response_buffer += sizeof( TPM_RC ); } // Receive the TPM response. rval = recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)response_buffer, ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize - responseSizeDelta ); if( rval != TSS2_RC_SUCCESS ) goto retSocketReceiveTpmResponse; #ifdef DEBUG if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED ) { DEBUG_PRINT_BUFFER( response_buffer, ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize ); } #endif // Receive the appended four bytes of 0's rval = recvBytes( TCTI_CONTEXT_INTEL->tpmSock, (unsigned char *)&trash, 4 ); if( rval != TSS2_RC_SUCCESS ) goto retSocketReceiveTpmResponse; } if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize < *response_size ) { *response_size = ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->responseSize; } ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->status.commandSent = 0; // Turn cancel off. if( rval == TSS2_RC_SUCCESS ) { rval = (TSS2_RC)PlatformCommand( tctiContext, MS_SIM_CANCEL_OFF ); } else { // Ignore return value so earlier error code is preserved. PlatformCommand( tctiContext, MS_SIM_CANCEL_OFF ); } if( ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext )->status.debugMsgLevel == TSS2_TCTI_DEBUG_MSG_ENABLED ) { // (*printfFunction)(NO_PREFIX, "%s sent cancel OFF command:\n", interfaceName ); } retSocketReceiveTpmResponse: if( rval == TSS2_RC_SUCCESS && response_buffer != NULL ) { ((TSS2_TCTI_CONTEXT_INTEL *)tctiContext)->previousStage = TCTI_STAGE_RECEIVE_RESPONSE; } return rval; }