Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229// SPDX-License-Identifier: GPL-2.0+/* * SSH message parser. * * Copyright (C) 2019-2022 Maximilian Luz <luzmaximilian@gmail.com> */
#include <linux/unaligned.h>#include <linux/compiler.h>#include <linux/device.h>#include <linux/types.h>
#include <linux/surface_aggregator/serial_hub.h>#include "ssh_parser.h"
/** * sshp_validate_crc() - Validate a CRC in raw message data. * @src: The span of data over which the CRC should be computed. * @crc: The pointer to the expected u16 CRC value. * * Computes the CRC of the provided data span (@src), compares it to the CRC * stored at the given address (@crc), and returns the result of this * comparison, i.e. %true if equal. This function is intended to run on raw * input/message data. * * Return: Returns %true if the computed CRC matches the stored CRC, %false * otherwise. */static bool sshp_validate_crc(const struct ssam_span *src, const u8 *crc){ u16 actual = ssh_crc(src->ptr, src->len); u16 expected = get_unaligned_le16(crc);
return actual == expected;}
/** * sshp_starts_with_syn() - Check if the given data starts with SSH SYN bytes. * @src: The data span to check the start of. */static bool sshp_starts_with_syn(const struct ssam_span *src){ return src->len >= 2 && get_unaligned_le16(src->ptr) == SSH_MSG_SYN;}
/** * sshp_find_syn() - Find SSH SYN bytes in the given data span. * @src: The data span to search in. * @rem: The span (output) indicating the remaining data, starting with SSH * SYN bytes, if found. * * Search for SSH SYN bytes in the given source span. If found, set the @rem * span to the remaining data, starting with the first SYN bytes and capped by * the source span length, and return %true. This function does not copy any * data, but rather only sets pointers to the respective start addresses and * length values. * * If no SSH SYN bytes could be found, set the @rem span to the zero-length * span at the end of the source span and return %false. * * If partial SSH SYN bytes could be found at the end of the source span, set * the @rem span to cover these partial SYN bytes, capped by the end of the * source span, and return %false. This function should then be re-run once * more data is available. * * Return: Returns %true if a complete SSH SYN sequence could be found, * %false otherwise. */bool sshp_find_syn(const struct ssam_span *src, struct ssam_span *rem){ size_t i;
for (i = 0; i < src->len - 1; i++) { if (likely(get_unaligned_le16(src->ptr + i) == SSH_MSG_SYN)) { rem->ptr = src->ptr + i; rem->len = src->len - i; return true; } }
if (unlikely(src->ptr[src->len - 1] == (SSH_MSG_SYN & 0xff))) { rem->ptr = src->ptr + src->len - 1; rem->len = 1; return false; }
rem->ptr = src->ptr + src->len; rem->len = 0; return false;}
/** * sshp_parse_frame() - Parse SSH frame. * @dev: The device used for logging. * @source: The source to parse from. * @frame: The parsed frame (output). * @payload: The parsed payload (output). * @maxlen: The maximum supported message length. * * Parses and validates a SSH frame, including its payload, from the given * source. Sets the provided @frame pointer to the start of the frame and * writes the limits of the frame payload to the provided @payload span * pointer. * * This function does not copy any data, but rather only validates the message * data and sets pointers (and length values) to indicate the respective parts. * * If no complete SSH frame could be found, the frame pointer will be set to * the %NULL pointer and the payload span will be set to the null span (start * pointer %NULL, size zero). * * Return: Returns zero on success or if the frame is incomplete, %-ENOMSG if * the start of the message is invalid, %-EBADMSG if any (frame-header or * payload) CRC is invalid, or %-EMSGSIZE if the SSH message is bigger than * the maximum message length specified in the @maxlen parameter. */int sshp_parse_frame(const struct device *dev, const struct ssam_span *source, struct ssh_frame **frame, struct ssam_span *payload, size_t maxlen){ struct ssam_span sf; struct ssam_span sp;
/* Initialize output. */ *frame = NULL; payload->ptr = NULL; payload->len = 0;
if (!sshp_starts_with_syn(source)) { dev_warn(dev, "rx: parser: invalid start of frame\n"); return -ENOMSG; }
/* Check for minimum packet length. */ if (unlikely(source->len < SSH_MESSAGE_LENGTH(0))) { dev_dbg(dev, "rx: parser: not enough data for frame\n"); return 0; }
/* Pin down frame. */ sf.ptr = source->ptr + sizeof(u16); sf.len = sizeof(struct ssh_frame);
/* Validate frame CRC. */ if (unlikely(!sshp_validate_crc(&sf, sf.ptr + sf.len))) { dev_warn(dev, "rx: parser: invalid frame CRC\n"); return -EBADMSG; }
/* Ensure packet does not exceed maximum length. */ sp.len = get_unaligned_le16(&((struct ssh_frame *)sf.ptr)->len); if (unlikely(SSH_MESSAGE_LENGTH(sp.len) > maxlen)) { dev_warn(dev, "rx: parser: frame too large: %llu bytes\n", SSH_MESSAGE_LENGTH(sp.len)); return -EMSGSIZE; }
/* Pin down payload. */ sp.ptr = sf.ptr + sf.len + sizeof(u16);
/* Check for frame + payload length. */ if (source->len < SSH_MESSAGE_LENGTH(sp.len)) { dev_dbg(dev, "rx: parser: not enough data for payload\n"); return 0; }
/* Validate payload CRC. */ if (unlikely(!sshp_validate_crc(&sp, sp.ptr + sp.len))) { dev_warn(dev, "rx: parser: invalid payload CRC\n"); return -EBADMSG; }
*frame = (struct ssh_frame *)sf.ptr; *payload = sp;
dev_dbg(dev, "rx: parser: valid frame found (type: %#04x, len: %u)\n", (*frame)->type, (*frame)->len);
return 0;}
/** * sshp_parse_command() - Parse SSH command frame payload. * @dev: The device used for logging. * @source: The source to parse from. * @command: The parsed command (output). * @command_data: The parsed command data/payload (output). * * Parses and validates a SSH command frame payload. Sets the @command pointer * to the command header and the @command_data span to the command data (i.e. * payload of the command). This will result in a zero-length span if the * command does not have any associated data/payload. This function does not * check the frame-payload-type field, which should be checked by the caller * before calling this function. * * The @source parameter should be the complete frame payload, e.g. returned * by the sshp_parse_frame() command. * * This function does not copy any data, but rather only validates the frame * payload data and sets pointers (and length values) to indicate the * respective parts. * * Return: Returns zero on success or %-ENOMSG if @source does not represent a * valid command-type frame payload, i.e. is too short. */int sshp_parse_command(const struct device *dev, const struct ssam_span *source, struct ssh_command **command, struct ssam_span *command_data){ /* Check for minimum length. */ if (unlikely(source->len < sizeof(struct ssh_command))) { *command = NULL; command_data->ptr = NULL; command_data->len = 0;
dev_err(dev, "rx: parser: command payload is too short\n"); return -ENOMSG; }
*command = (struct ssh_command *)source->ptr; command_data->ptr = source->ptr + sizeof(struct ssh_command); command_data->len = source->len - sizeof(struct ssh_command);
dev_dbg(dev, "rx: parser: valid command found (tc: %#04x, cid: %#04x)\n", (*command)->tc, (*command)->cid);
return 0;}