forked from DGNum/liminix
17355c3911
The way the parsing works is examining one character at a time. First, if we had `rootfstype=... root=...`, the parsing would jump and ignore `root=...`, which sucks. To fix this, we scan multiple times a copy of the cmdline. Now, we have a new problem: `root=... altroot=...` lead to opts.device being equal to the altroot as we are looking one char at a time, so we will arrive at a moment looking at `root=...` for `altroot=...`. To avoid this, we rename `altroot` in `rootalt`, cheap, I know. Signed-off-by: Raito Bezarius <masterancpp@gmail.com>
179 lines
6.3 KiB
C
179 lines
6.3 KiB
C
#include <unistd.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "opts.h"
|
|
|
|
|
|
static int begins_with(char * str, char * prefix)
|
|
{
|
|
while(*prefix) {
|
|
if(*str == '\0') return 0;
|
|
if(*str != *prefix) return 0;
|
|
str++;
|
|
prefix++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
char * pr_u32(int32_t input) {
|
|
static char buf[9];
|
|
const char *digits = "0123456789abcdef";
|
|
int i=0;
|
|
|
|
buf[i] = digits[(input & 0xf0000000) >> 28];
|
|
buf[i+1] = digits[(input & 0x0f000000) >> 24];
|
|
if(buf[i] != '0' || buf[i+1] != '0') i+=2;
|
|
|
|
buf[i] = digits[(input & 0x00f00000) >> 20];
|
|
buf[i+1] = digits[(input & 0x000f0000) >> 16];
|
|
if(buf[i] != '0' || buf[i+1] != '0') i+=2;
|
|
|
|
buf[i] = digits[(input & 0x0000f000) >> 12];
|
|
buf[i+1] = digits[(input & 0x00000f00) >> 8];
|
|
if(buf[i] != '0' || buf[i+1] != '0') i+=2;
|
|
|
|
buf[i] = digits[(input & 0x000000f0) >> 4];
|
|
buf[i+1] = digits[(input & 0x0000000f)];
|
|
i+=2;
|
|
|
|
buf[i] ='\0';
|
|
if(write(2, buf, i))
|
|
return buf;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static char *eat_word(char *p)
|
|
{
|
|
while(*p && (*p != ' ')) p++;
|
|
|
|
if(*p) {
|
|
*p = '\0';
|
|
p++;
|
|
};
|
|
return p;
|
|
}
|
|
|
|
static char * eat_param(char *p, char *param_name, char **out)
|
|
{
|
|
if(begins_with(p, param_name)) {
|
|
*out = p + strlen(param_name);
|
|
p = eat_word(p);
|
|
};
|
|
return p;
|
|
}
|
|
|
|
#define SCAN_CMDLINE(cmdline, identifier, field) do { \
|
|
for (char* p = strdup(cmdline); *p; p++) { \
|
|
p = eat_param(p, identifier, &(opts->field)); \
|
|
} \
|
|
} while(0)
|
|
|
|
|
|
void parseopts(char * cmdline, struct root_opts *opts) {
|
|
SCAN_CMDLINE(cmdline, "root=", device);
|
|
SCAN_CMDLINE(cmdline, "rootfstype=", fstype);
|
|
SCAN_CMDLINE(cmdline, "rootflags=", mount_opts);
|
|
SCAN_CMDLINE(cmdline, "rootalt=", altdevice);
|
|
}
|
|
|
|
#ifdef TESTS
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
// cc -DTESTS -o parseopts parseopts.c && ./parseopts
|
|
|
|
#define die(fmt, ...) do { printf(fmt, __VA_ARGS__); exit(1); } while(0)
|
|
#define S(x) #x
|
|
#define expect_equal(actual, expected) \
|
|
if(!actual || strcmp(actual, expected)) die("%d: expected \"%s\", got \"%s\"", __LINE__, expected, actual);
|
|
#define expect_null(actual) \
|
|
if (actual) die("%d: expected null, got \"%s\"", __LINE__, actual);
|
|
|
|
|
|
int main()
|
|
{
|
|
struct root_opts opts = {
|
|
.device = "/dev/hda1",
|
|
.fstype = "xiafs",
|
|
.altdevice = NULL,
|
|
.mount_opts = NULL
|
|
};
|
|
char *buf;
|
|
|
|
// finds root= rootfstype= rootflags= options
|
|
buf = strdup("liminix console=ttyS0,115200 panic=10 oops=panic init=/bin/init loglevel=8 root=/dev/ubi0_4 rootfstype=ubifs rootflags=subvol=1 fw_devlink=off mtdparts=phram0:18M(rootfs) phram.phram=phram0,0x40400000,18874368,65536 root=/dev/mtdblock0 foo");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/mtdblock0");
|
|
expect_equal(opts.fstype, "ubifs");
|
|
expect_equal(opts.mount_opts, "subvol=1");
|
|
|
|
// finds rootalt= options
|
|
buf = strdup("liminix console=ttyS0,115200 panic=10 oops=panic init=/bin/init loglevel=8 root=/dev/ubi0_4 rootfstype=ubifs rootflags=subvol=1 fw_devlink=off mtdparts=phram0:18M(rootfs) phram.phram=phram0,0x40400000,18874368,65536 root=/dev/mtdblock0 rootalt=/dev/mtdblock6 foo");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/mtdblock0");
|
|
expect_equal(opts.altdevice, "/dev/mtdblock6");
|
|
expect_equal(opts.fstype, "ubifs");
|
|
expect_equal(opts.mount_opts, "subvol=1");
|
|
|
|
// Ensure that `altdevice` is NULL.
|
|
buf = strdup("liminix console=ttyS0,115200 panic=10 oops=panic init=/bin/init loglevel=8 fw_devlink=off rootfstype=ubifs mtdparts=phram0:19791872(rootfs) phram.phram=phram0,33554432,19791872,65536 rootfstype=jffs2 root=/dev/mtdblock0");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/mtdblock0");
|
|
expect_null(opts.altdevice);
|
|
expect_equal(opts.fstype, "jffs2");
|
|
expect_null(opts.mount_opts);
|
|
|
|
// in case of duplicates, chooses the latter
|
|
// also: works if the option is end of string
|
|
buf = strdup("liminix console=ttyS0,115200 panic=10 oops=panic init=/bin/init loglevel=8 root=/dev/ubi0_4 rootfstype=ubifs fw_devlink=off mtdparts=phram0:18M(rootfs) phram.phram=phram0,0x40400000,18874368,65536 root=/dev/mtdblock0");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/mtdblock0");
|
|
expect_equal(opts.fstype, "ubifs");
|
|
|
|
// options may appear in either order
|
|
buf = strdup("liminix fw_devlink=off root=/dev/hda1 rootfstype=ubifs foo");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/hda1");
|
|
expect_equal(opts.fstype, "ubifs");
|
|
|
|
// works when rootflags is the last option
|
|
buf = strdup("liminix fw_devlink=off root=/dev/hda1 rootfstype=ubifs rootflags=subvol=@");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.device, "/dev/hda1");
|
|
expect_equal(opts.fstype, "ubifs");
|
|
expect_equal(opts.mount_opts, "subvol=@");
|
|
|
|
buf = strdup("liminix rootfstype=ubifs fw_devlink=off root=/dev/hda1 foo");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
expect_equal(opts.fstype, "ubifs");
|
|
expect_equal(opts.device, "/dev/hda1");
|
|
|
|
// provides NULL for missing options
|
|
buf = strdup("liminix rufustype=ubifs fw_devlink=off foot=/dev/hda1");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
|
|
if(opts.fstype) die("expected null rootfstype, got \"%s\"", opts.fstype);
|
|
if(opts.device) die("expected null root, got \"%s\"", opts.device);
|
|
if(opts.mount_opts) die("expected null mount_opts, got \"%s\"", opts.mount_opts);
|
|
if(opts.altdevice) die("expected null altdevice, got \"%s\"", opts.altdevice);
|
|
|
|
// provides empty strings for empty options
|
|
buf = strdup("liminix rootfstype= fw_devlink=off root= rootalt= /dev/hda1");
|
|
memset(&opts, '\0', sizeof opts); parseopts(buf, &opts);
|
|
|
|
if(strlen(opts.fstype)) die("expected empty rootfstype, got \"%s\"", opts.fstype);
|
|
if(strlen(opts.device)) die("expected empty root, got \"%s\"", opts.device);
|
|
if(strlen(opts.altdevice)) die("expected empty rootalt, got \"%s\"", opts.altdevice);
|
|
|
|
expect_equal("01", pr_u32(1));
|
|
expect_equal("ab", pr_u32(0xab));
|
|
expect_equal("0abc", pr_u32(0xabc));
|
|
expect_equal("aabc", pr_u32(0xaabc));
|
|
expect_equal("deadcafe", pr_u32(0xdeadcafe));
|
|
}
|
|
|
|
#endif
|