SSL storage.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/* RomFS storage access routines
 *
 * Copyright © 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/fs.h>
#include <linux/mtd/super.h>
#include <linux/buffer_head.h>
#include "internal.h"

#if !defined(CONFIG_ROMFS_ON_MTD) && !defined(CONFIG_ROMFS_ON_BLOCK)
#error no ROMFS backing store interface configured
#endif

#ifdef CONFIG_ROMFS_ON_MTD
#define ROMFS_MTD_READ(sb, ...) mtd_read((sb)->s_mtd, ##__VA_ARGS__)

/*
 * read data from an romfs image on an MTD device
 */
static int romfs_mtd_read(struct super_block *sb, unsigned long pos,
     void *buf, size_t buflen)
{
 size_t rlen;
 int ret;

 ret = ROMFS_MTD_READ(sb, pos, buflen, &rlen, buf);
 return (ret < 0 || rlen != buflen) ? -EIO : 0;
}

/*
 * determine the length of a string in a romfs image on an MTD device
 */
static ssize_t romfs_mtd_strnlen(struct super_block *sb,
     unsigned long pos, size_t maxlen)
{
 ssize_t n = 0;
 size_t segment;
 u_char buf[16], *p;
 size_t len;
 int ret;

 /* scan the string up to 16 bytes at a time */
 while (maxlen > 0) {
  segment = min_t(size_t, maxlen, 16);
  ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
  if (ret < 0)
   return ret;
  p = memchr(buf, 0, len);
  if (p)
   return n + (p - buf);
  maxlen -= len;
  pos += len;
  n += len;
 }

 return n;
}

/*
 * compare a string to one in a romfs image on MTD
 * - return 1 if matched, 0 if differ, -ve if error
 */
static int romfs_mtd_strcmp(struct super_block *sb, unsigned long pos,
       const char *str, size_t size)
{
 u_char buf[17];
 size_t len, segment;
 int ret;

 /* scan the string up to 16 bytes at a time, and attempt to grab the
 * trailing NUL whilst we're at it */
 buf[0] = 0xff;

 while (size > 0) {
  segment = min_t(size_t, size + 1, 17);
  ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
  if (ret < 0)
   return ret;
  len--;
  if (memcmp(buf, str, len) != 0)
   return 0;
  buf[0] = buf[len];
  size -= len;
  pos += len;
  str += len;
 }

 /* check the trailing NUL was */
 if (buf[0])
  return 0;

 return 1;
}
#endif /* CONFIG_ROMFS_ON_MTD */

#ifdef CONFIG_ROMFS_ON_BLOCK
/*
 * read data from an romfs image on a block device
 */
static int romfs_blk_read(struct super_block *sb, unsigned long pos,
     void *buf, size_t buflen)
{
 struct buffer_head *bh;
 unsigned long offset;
 size_t segment;

 /* copy the string up to blocksize bytes at a time */
 while (buflen > 0) {
  offset = pos & (ROMBSIZE - 1);
  segment = min_t(size_t, buflen, ROMBSIZE - offset);
  bh = sb_bread(sb, pos >> ROMBSBITS);
  if (!bh)
   return -EIO;
  memcpy(buf, bh->b_data + offset, segment);
  brelse(bh);
  buf += segment;
  buflen -= segment;
  pos += segment;
 }

 return 0;
}

/*
 * determine the length of a string in romfs on a block device
 */
static ssize_t romfs_blk_strnlen(struct super_block *sb,
     unsigned long pos, size_t limit)
{
 struct buffer_head *bh;
 unsigned long offset;
 ssize_t n = 0;
 size_t segment;
 u_char *buf, *p;

 /* scan the string up to blocksize bytes at a time */
 while (limit > 0) {
  offset = pos & (ROMBSIZE - 1);
  segment = min_t(size_t, limit, ROMBSIZE - offset);
  bh = sb_bread(sb, pos >> ROMBSBITS);
  if (!bh)
   return -EIO;
  buf = bh->b_data + offset;
  p = memchr(buf, 0, segment);
  brelse(bh);
  if (p)
   return n + (p - buf);
  limit -= segment;
  pos += segment;
  n += segment;
 }

 return n;
}

/*
 * compare a string to one in a romfs image on a block device
 * - return 1 if matched, 0 if differ, -ve if error
 */
static int romfs_blk_strcmp(struct super_block *sb, unsigned long pos,
       const char *str, size_t size)
{
 struct buffer_head *bh;
 unsigned long offset;
 size_t segment;
 bool matched, terminated = false;

 /* compare string up to a block at a time */
 while (size > 0) {
  offset = pos & (ROMBSIZE - 1);
  segment = min_t(size_t, size, ROMBSIZE - offset);
  bh = sb_bread(sb, pos >> ROMBSBITS);
  if (!bh)
   return -EIO;
  matched = (memcmp(bh->b_data + offset, str, segment) == 0);

  size -= segment;
  pos += segment;
  str += segment;
  if (matched && size == 0 && offset + segment < ROMBSIZE) {
   if (!bh->b_data[offset + segment])
    terminated = true;
   else
    matched = false;
  }
  brelse(bh);
  if (!matched)
   return 0;
 }

 if (!terminated) {
  /* the terminating NUL must be on the first byte of the next
 * block */
  BUG_ON((pos & (ROMBSIZE - 1)) != 0);
  bh = sb_bread(sb, pos >> ROMBSBITS);
  if (!bh)
   return -EIO;
  matched = !bh->b_data[0];
  brelse(bh);
  if (!matched)
   return 0;
 }

 return 1;
}
#endif /* CONFIG_ROMFS_ON_BLOCK */

/*
 * read data from the romfs image
 */
int romfs_dev_read(struct super_block *sb, unsigned long pos,
     void *buf, size_t buflen)
{
 size_t limit;

 limit = romfs_maxsize(sb);
 if (pos >= limit || buflen > limit - pos)
  return -EIO;

#ifdef CONFIG_ROMFS_ON_MTD
 if (sb->s_mtd)
  return romfs_mtd_read(sb, pos, buf, buflen);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
 if (sb->s_bdev)
  return romfs_blk_read(sb, pos, buf, buflen);
#endif
 return -EIO;
}

/*
 * determine the length of a string in romfs
 */
ssize_t romfs_dev_strnlen(struct super_block *sb,
     unsigned long pos, size_t maxlen)
{
 size_t limit;

 limit = romfs_maxsize(sb);
 if (pos >= limit)
  return -EIO;
 if (maxlen > limit - pos)
  maxlen = limit - pos;

#ifdef CONFIG_ROMFS_ON_MTD
 if (sb->s_mtd)
  return romfs_mtd_strnlen(sb, pos, maxlen);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
 if (sb->s_bdev)
  return romfs_blk_strnlen(sb, pos, maxlen);
#endif
 return -EIO;
}

/*
 * compare a string to one in romfs
 * - the string to be compared to, str, may not be NUL-terminated; instead the
 *   string is of the specified size
 * - return 1 if matched, 0 if differ, -ve if error
 */
int romfs_dev_strcmp(struct super_block *sb, unsigned long pos,
       const char *str, size_t size)
{
 size_t limit;

 limit = romfs_maxsize(sb);
 if (pos >= limit)
  return -EIO;
 if (size > ROMFS_MAXFN)
  return -ENAMETOOLONG;
 if (size + 1 > limit - pos)
  return -EIO;

#ifdef CONFIG_ROMFS_ON_MTD
 if (sb->s_mtd)
  return romfs_mtd_strcmp(sb, pos, str, size);
#endif
#ifdef CONFIG_ROMFS_ON_BLOCK
 if (sb->s_bdev)
  return romfs_blk_strcmp(sb, pos, str, size);
#endif
 return -EIO;
}