142 lines
3.6 KiB
C
142 lines
3.6 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* Copyright 2012 Intel Corporation; author H. Peter Anvin
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* earlycpio.c
|
|
*
|
|
* Find a specific cpio member; must precede any compressed content.
|
|
* This is used to locate data items in the initramfs used by the
|
|
* kernel itself during early boot (before the main initramfs is
|
|
* decompressed.) It is the responsibility of the initramfs creator
|
|
* to ensure that these items are uncompressed at the head of the
|
|
* blob. Depending on the boot loader or package tool that may be a
|
|
* separate file or part of the same file.
|
|
*/
|
|
|
|
#include <linux/earlycpio.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
|
|
enum cpio_fields {
|
|
C_MAGIC,
|
|
C_INO,
|
|
C_MODE,
|
|
C_UID,
|
|
C_GID,
|
|
C_NLINK,
|
|
C_MTIME,
|
|
C_FILESIZE,
|
|
C_MAJ,
|
|
C_MIN,
|
|
C_RMAJ,
|
|
C_RMIN,
|
|
C_NAMESIZE,
|
|
C_CHKSUM,
|
|
C_NFIELDS
|
|
};
|
|
|
|
/**
|
|
* find_cpio_data - Search for files in an uncompressed cpio
|
|
* @path: The directory to search for, including a slash at the end
|
|
* @data: Pointer to the cpio archive or a header inside
|
|
* @len: Remaining length of the cpio based on data pointer
|
|
* @nextoff: When a matching file is found, this is the offset from the
|
|
* beginning of the cpio to the beginning of the next file, not the
|
|
* matching file itself. It can be used to iterate through the cpio
|
|
* to find all files inside of a directory path.
|
|
*
|
|
* Return: &struct cpio_data containing the address, length and
|
|
* filename (with the directory path cut off) of the found file.
|
|
* If you search for a filename and not for files in a directory,
|
|
* pass the absolute path of the filename in the cpio and make sure
|
|
* the match returned an empty filename string.
|
|
*/
|
|
|
|
struct cpio_data find_cpio_data(const char *path, void *data,
|
|
size_t len, long *nextoff)
|
|
{
|
|
const size_t cpio_header_len = 8*C_NFIELDS - 2;
|
|
struct cpio_data cd = { NULL, 0, "" };
|
|
const char *p, *dptr, *nptr;
|
|
unsigned int ch[C_NFIELDS], *chp, v;
|
|
unsigned char c, x;
|
|
size_t mypathsize = strlen(path);
|
|
int i, j;
|
|
|
|
p = data;
|
|
|
|
while (len > cpio_header_len) {
|
|
if (!*p) {
|
|
/* All cpio headers need to be 4-byte aligned */
|
|
p += 4;
|
|
len -= 4;
|
|
continue;
|
|
}
|
|
|
|
j = 6; /* The magic field is only 6 characters */
|
|
chp = ch;
|
|
for (i = C_NFIELDS; i; i--) {
|
|
v = 0;
|
|
while (j--) {
|
|
v <<= 4;
|
|
c = *p++;
|
|
|
|
x = c - '0';
|
|
if (x < 10) {
|
|
v += x;
|
|
continue;
|
|
}
|
|
|
|
x = (c | 0x20) - 'a';
|
|
if (x < 6) {
|
|
v += x + 10;
|
|
continue;
|
|
}
|
|
|
|
goto quit; /* Invalid hexadecimal */
|
|
}
|
|
*chp++ = v;
|
|
j = 8; /* All other fields are 8 characters */
|
|
}
|
|
|
|
if ((ch[C_MAGIC] - 0x070701) > 1)
|
|
goto quit; /* Invalid magic */
|
|
|
|
len -= cpio_header_len;
|
|
|
|
dptr = PTR_ALIGN(p + ch[C_NAMESIZE], 4);
|
|
nptr = PTR_ALIGN(dptr + ch[C_FILESIZE], 4);
|
|
|
|
if (nptr > p + len || dptr < p || nptr < dptr)
|
|
goto quit; /* Buffer overrun */
|
|
|
|
if ((ch[C_MODE] & 0170000) == 0100000 &&
|
|
ch[C_NAMESIZE] >= mypathsize &&
|
|
!memcmp(p, path, mypathsize)) {
|
|
|
|
if (nextoff)
|
|
*nextoff = (long)nptr - (long)data;
|
|
|
|
if (ch[C_NAMESIZE] - mypathsize >= MAX_CPIO_FILE_NAME) {
|
|
pr_warn(
|
|
"File %s exceeding MAX_CPIO_FILE_NAME [%d]\n",
|
|
p, MAX_CPIO_FILE_NAME);
|
|
}
|
|
strscpy(cd.name, p + mypathsize, MAX_CPIO_FILE_NAME);
|
|
|
|
cd.data = (void *)dptr;
|
|
cd.size = ch[C_FILESIZE];
|
|
return cd; /* Found it! */
|
|
}
|
|
len -= (nptr - p);
|
|
p = nptr;
|
|
}
|
|
|
|
quit:
|
|
return cd;
|
|
}
|