int cmd_interface_spdm_process_request()

in core/spdm/cmd_interface_spdm_responder.c [21:132]

• 84 lines of code
• 22 McCabe index (conditional complexity)

int cmd_interface_spdm_process_request (const struct cmd_interface *intf,
	struct cmd_interface_msg *request)
{
	const struct cmd_interface_spdm_responder *spdm_responder =
		(const struct cmd_interface_spdm_responder*) intf;
	uint8_t req_code;
	int status = 0;
	struct spdm_secure_session_manager *session_manager;

	if ((spdm_responder == NULL) || (request == NULL)) {
		status = CMD_HANDLER_SPDM_RESPONDER_INVALID_ARGUMENT;
		goto exit;
	}
	session_manager = spdm_responder->session_manager;

	/* Reset the validity of the last session id. */
	if (session_manager != NULL) {
		session_manager->reset_last_session_id_validity (session_manager);
	}

	/* If the request is secure, decode it. */
	if (request->is_encrypted == true) {
		if (session_manager == NULL) {
			status = CMD_HANDLER_SPDM_RESPONDER_INVALID_REQUEST;
			goto exit;
		}

		status = session_manager->decode_secure_message (session_manager, request);
		if (status != 0) {
			/* Note: Response is not being encoded in case of a decode failure. */
			spdm_generate_error_response (request, 0, SPDM_ERROR_DECRYPT_ERROR, 0x00, NULL, 0, 0,
				status);
			status = 0;
			goto exit;
		}
	}

	/* Pre-process the request and get the command Id. */
	status = spdm_get_command_id (request, &req_code);
	if (status != 0) {
		goto exit;
	}

	switch (req_code) {
		case SPDM_REQUEST_GET_VERSION:
			status = spdm_get_version (spdm_responder, request);
			break;

		case SPDM_REQUEST_GET_CAPABILITIES:
			status = spdm_get_capabilities (spdm_responder, request);
			break;

		case SPDM_REQUEST_NEGOTIATE_ALGORITHMS:
			status = spdm_negotiate_algorithms (spdm_responder, request);
			break;

		case SPDM_REQUEST_GET_DIGESTS:
			status = spdm_get_digests (spdm_responder, request);
			break;

		case SPDM_REQUEST_GET_CERTIFICATE:
			status = spdm_get_certificate (spdm_responder, request);
			break;

		case SPDM_REQUEST_CHALLENGE:
			status = spdm_challenge (spdm_responder, request);
			break;

		case SPDM_REQUEST_GET_MEASUREMENTS:
			status = spdm_get_measurements (spdm_responder, request);
			break;

		case SPDM_REQUEST_KEY_EXCHANGE:
			status = spdm_key_exchange (spdm_responder, request);
			break;

		case SPDM_REQUEST_FINISH:
			status = spdm_finish (spdm_responder, request);
			break;

		case SPDM_REQUEST_END_SESSION:
			status = spdm_end_session (spdm_responder, request);
			break;

		case SPDM_REQUEST_VENDOR_DEFINED_REQUEST:
			status = spdm_vendor_defined_request (spdm_responder, request);
			break;

		default:
			spdm_generate_error_response (request, 0, SPDM_ERROR_UNSUPPORTED_REQUEST, 0x00, NULL, 0,
				req_code, CMD_HANDLER_SPDM_RESPONDER_UNSUPPORTED_OPERATION);
			break;
	}

	if ((status == 0) && (request->is_encrypted == true)) {
		/* If the request was encoded and was succesfully decoded, encode the response. */
		status = session_manager->encode_secure_message (session_manager, request);
		if (status != 0) {
			/**
			 * Note: An error of SPDM_ERROR_DECRYPT_ERROR is being sent to the requester to
			 * to terminate the session. */
			spdm_generate_error_response (request, 0, SPDM_ERROR_DECRYPT_ERROR, 0x00, NULL, 0,
				req_code, status);
			status = 0;
			goto exit;
		}
	}

exit:

	return status;
}