char hex_digit(const long double value) {
return hex_digit(static_cast<long>(value));
}
static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
HANDLE h;
NTSTATUS Status;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING path, adus;
UINT32 degraded = mount_allow_degraded;
ULONG i, j, kvfilen, retlen;
KEY_VALUE_FULL_INFORMATION* kvfi;
path.Length = path.MaximumLength = registry_path.Length + (37 * sizeof(WCHAR));
path.Buffer = ExAllocatePoolWithTag(PagedPool, path.Length, ALLOC_TAG);
if (!path.Buffer) {
ERR("out of memory\n");
return FALSE;
}
RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
i = registry_path.Length / sizeof(WCHAR);
path.Buffer[i] = '\\';
i++;
for (j = 0; j < 16; j++) {
path.Buffer[i] = hex_digit((uuid->uuid[j] & 0xF0) >> 4);
path.Buffer[i+1] = hex_digit(uuid->uuid[j] & 0xF);
i += 2;
if (j == 3 || j == 5 || j == 7 || j == 9) {
path.Buffer[i] = '-';
i++;
}
}
InitializeObjectAttributes(&oa, &path, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
kvfilen = (ULONG)offsetof(KEY_VALUE_FULL_INFORMATION, Name[0]) + (255 * sizeof(WCHAR));
kvfi = ExAllocatePoolWithTag(PagedPool, kvfilen, ALLOC_TAG);
if (!kvfi) {
ERR("out of memory\n");
ExFreePool(path.Buffer);
return FALSE;
}
Status = ZwOpenKey(&h, KEY_QUERY_VALUE, &oa);
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
goto end;
else if (!NT_SUCCESS(Status)) {
ERR("ZwOpenKey returned %08x\n", Status);
goto end;
}
adus.Buffer = L"AllowDegraded";
adus.Length = adus.MaximumLength = sizeof(adus.Buffer) - sizeof(WCHAR);
if (NT_SUCCESS(ZwQueryValueKey(h, &adus, KeyValueFullInformation, kvfi, kvfilen, &retlen))) {
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
UINT32* val = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
degraded = *val;
}
}
ZwClose(h);
end:
ExFreePool(kvfi);
ExFreePool(path.Buffer);
return degraded;
}
int
main(int argc, char **argv)
{
FILE *f;
const EVP_AEAD *aead = NULL;
unsigned int line_no = 0, num_tests = 0, j;
unsigned char bufs[NUM_TYPES][BUF_MAX];
unsigned int lengths[NUM_TYPES];
if (argc != 2) {
fprintf(stderr, "%s <test file.txt>\n", argv[0]);
return 1;
}
f = fopen(argv[1], "r");
if (f == NULL) {
perror("failed to open input");
return 1;
}
for (j = 0; j < NUM_TYPES; j++)
lengths[j] = 0;
for (;;) {
char line[4096];
unsigned int i, type_len = 0;
unsigned char *buf = NULL;
unsigned int *buf_len = NULL;
if (!fgets(line, sizeof(line), f))
break;
line_no++;
if (line[0] == '#')
continue;
if (line[0] == '\n' || line[0] == 0) {
/* Run a test, if possible. */
char any_values_set = 0;
for (j = 0; j < NUM_TYPES; j++) {
if (lengths[j] != 0) {
any_values_set = 1;
break;
}
}
if (!any_values_set)
continue;
switch (aead_from_name(&aead, bufs[AEAD])) {
case 0:
fprintf(stderr, "Skipping test...\n");
continue;
case -1:
fprintf(stderr, "Aborting...\n");
return 4;
}
if (!run_test_case(aead, bufs, lengths, line_no))
return 4;
for (j = 0; j < NUM_TYPES; j++)
lengths[j] = 0;
num_tests++;
continue;
}
/* Each line looks like:
* TYPE: 0123abc
* Where "TYPE" is the type of the data on the line,
* e.g. "KEY". */
for (i = 0; line[i] != 0 && line[i] != '\n'; i++) {
if (line[i] == ':') {
type_len = i;
break;
}
}
i++;
if (type_len == 0) {
fprintf(stderr, "Parse error on line %u\n", line_no);
return 3;
}
/* After the colon, there's optional whitespace. */
for (; line[i] != 0 && line[i] != '\n'; i++) {
if (line[i] != ' ' && line[i] != '\t')
break;
}
line[type_len] = 0;
for (j = 0; j < NUM_TYPES; j++) {
if (strcmp(line, NAMES[j]) != 0)
continue;
if (lengths[j] != 0) {
fprintf(stderr, "Duplicate value on line %u\n",
line_no);
return 3;
}
buf = bufs[j];
buf_len = &lengths[j];
break;
}
if (buf == NULL) {
fprintf(stderr, "Unknown line type on line %u\n",
line_no);
return 3;
}
if (j == AEAD) {
*buf_len = strlcpy(buf, line + i, BUF_MAX);
for (j = 0; j < BUF_MAX; j++) {
if (buf[j] == '\n')
buf[j] = '\0';
}
continue;
}
for (j = 0; line[i] != 0 && line[i] != '\n'; i++) {
unsigned char v, v2;
v = hex_digit(line[i++]);
if (line[i] == 0 || line[i] == '\n') {
fprintf(stderr, "Odd-length hex data on "
"line %u\n", line_no);
return 3;
}
v2 = hex_digit(line[i]);
if (v > 15 || v2 > 15) {
fprintf(stderr, "Invalid hex char on line %u\n",
line_no);
return 3;
}
v <<= 4;
v |= v2;
if (j == BUF_MAX) {
fprintf(stderr, "Too much hex data on line %u "
"(max is %u bytes)\n",
line_no, (unsigned) BUF_MAX);
return 3;
}
buf[j++] = v;
*buf_len = *buf_len + 1;
}
}
printf("Completed %u test cases\n", num_tests);
printf("PASS\n");
fclose(f);
return 0;
}
static BOOL fs_ignored(BTRFS_UUID* uuid) {
UNICODE_STRING path, ignoreus;
NTSTATUS Status;
OBJECT_ATTRIBUTES oa;
KEY_VALUE_FULL_INFORMATION* kvfi;
ULONG dispos, retlen, kvfilen, i, j;
HANDLE h;
BOOL ret = FALSE;
path.Length = path.MaximumLength = registry_path.Length + (37 * sizeof(WCHAR));
path.Buffer = ExAllocatePoolWithTag(PagedPool, path.Length, ALLOC_TAG);
if (!path.Buffer) {
ERR("out of memory\n");
return FALSE;
}
RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
i = registry_path.Length / sizeof(WCHAR);
path.Buffer[i] = '\\';
i++;
for (j = 0; j < 16; j++) {
path.Buffer[i] = hex_digit((uuid->uuid[j] & 0xF0) >> 4);
path.Buffer[i+1] = hex_digit(uuid->uuid[j] & 0xF);
i += 2;
if (j == 3 || j == 5 || j == 7 || j == 9) {
path.Buffer[i] = '-';
i++;
}
}
InitializeObjectAttributes(&oa, &path, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
Status = ZwCreateKey(&h, KEY_QUERY_VALUE, &oa, 0, NULL, REG_OPTION_NON_VOLATILE, &dispos);
if (!NT_SUCCESS(Status)) {
TRACE("ZwCreateKey returned %08x\n", Status);
ExFreePool(path.Buffer);
return FALSE;
}
RtlInitUnicodeString(&ignoreus, L"Ignore");
kvfilen = (ULONG)offsetof(KEY_VALUE_FULL_INFORMATION, Name[0]) + (255 * sizeof(WCHAR));
kvfi = ExAllocatePoolWithTag(PagedPool, kvfilen, ALLOC_TAG);
if (!kvfi) {
ERR("out of memory\n");
ZwClose(h);
ExFreePool(path.Buffer);
return FALSE;
}
Status = ZwQueryValueKey(h, &ignoreus, KeyValueFullInformation, kvfi, kvfilen, &retlen);
if (NT_SUCCESS(Status)) {
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
UINT32* pr = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
ret = *pr;
}
}
ZwClose(h);
ExFreePool(kvfi);
ExFreePool(path.Buffer);
return ret;
}
string String::fromJsonRaw(std::istream& is) {
ostringstream oss{};
StringState state = StringState::NORMAL;
unsigned int u = 0;
int next_ch = skipWhitespace(is);
if (next_ch != '"')
throw runtime_error(
"Invalid input: Expected '\"', got: '" +
to_string(static_cast<char>(next_ch)) + "'");
readChar(is);
while (state != StringState::STRING_CLOSED) {
next_ch = is.peek();
if (next_ch == -1)
break;
switch (state) {
case StringState::NORMAL:
switch (next_ch) {
case '\\':
state = StringState::ESCAPE;
readChar(is);
break;
case '"':
state = StringState::STRING_CLOSED;
readChar(is);
break;
default:
oss << static_cast<char>(next_ch);
readChar(is);
break;
} // end switch(ch) //
break;
case StringState::ESCAPE:
switch (next_ch) {
case '"':
oss << '"';
state = StringState::NORMAL;
readChar(is);
break;
case '\\':
oss << '\\';
state = StringState::NORMAL;
readChar(is);
break;
case '/':
oss << '/';
state = StringState::NORMAL;
readChar(is);
break;
case 'b':
oss << '\b';
state = StringState::NORMAL;
readChar(is);
break;
case 'f':
oss << '\f';
state = StringState::NORMAL;
readChar(is);
break;
case 'n':
oss << '\n';
state = StringState::NORMAL;
readChar(is);
break;
case 'r':
oss << '\r';
state = StringState::NORMAL;
readChar(is);
break;
case 't':
oss << '\t';
state = StringState::NORMAL;
readChar(is);
break;
case 'u':
oss << '\b';
state = StringState::U0;
readChar(is);
break;
default:
throw runtime_error(
"Invalid escape sequence \"\\" +
to_string(static_cast<char>(next_ch)) + "\"");
} // end switch(ch)
break;
case StringState::U0:
u = hex_digit(static_cast<char>(next_ch));
state = StringState::U1;
readChar(is);
break;
case StringState::U1:
u = (16 * u) + hex_digit(static_cast<char>(next_ch));
state = StringState::U2;
readChar(is);
break;
case StringState::U2:
u = (16 * u) + hex_digit(static_cast<char>(next_ch));
state = StringState::U3;
readChar(is);
break;
case StringState::U3:
u = (16 * u) + hex_digit(static_cast<char>(next_ch));
oss << static_cast<char>(u);
state = StringState::NORMAL;
readChar(is);
break;
default:
throw runtime_error("ReadString: Invalid state " +
to_string(static_cast<int>(state)));
} // end switch(state) //
} // end for //
if (state != StringState::STRING_CLOSED)
throw runtime_error("String not closed in state " +
to_string(static_cast<int>(state)));
return oss.str();
}
static value_t read_string(void)
{
char *buf, *temp;
char eseq[10];
size_t i=0, j, sz = 64, ndig;
int c;
value_t s;
u_int32_t wc=0;
buf = malloc(sz);
while (1) {
if (i >= sz-4) { // -4: leaves room for longest utf8 sequence
sz *= 2;
temp = realloc(buf, sz);
if (temp == NULL) {
free(buf);
lerror(ParseError, "read: out of memory reading string");
}
buf = temp;
}
c = ios_getc(F);
if (c == IOS_EOF) {
free(buf);
lerror(ParseError, "read: unexpected end of input in string");
}
if (c == '"')
break;
else if (c == '\\') {
c = ios_getc(F);
if (c == IOS_EOF) {
free(buf);
lerror(ParseError, "read: end of input in escape sequence");
}
j=0;
if (octal_digit(c)) {
do {
eseq[j++] = c;
c = ios_getc(F);
} while (octal_digit(c) && j<3 && (c!=IOS_EOF));
if (c!=IOS_EOF) ios_ungetc(c, F);
eseq[j] = '\0';
wc = strtol(eseq, NULL, 8);
// \DDD and \xXX read bytes, not characters
buf[i++] = ((char)wc);
}
else if ((c=='x' && (ndig=2)) ||
(c=='u' && (ndig=4)) ||
(c=='U' && (ndig=8))) {
c = ios_getc(F);
while (hex_digit(c) && j<ndig && (c!=IOS_EOF)) {
eseq[j++] = c;
c = ios_getc(F);
}
if (c!=IOS_EOF) ios_ungetc(c, F);
eseq[j] = '\0';
if (j) wc = strtol(eseq, NULL, 16);
if (!j || wc > 0x10ffff) {
free(buf);
lerror(ParseError, "read: invalid escape sequence");
}
if (ndig == 2)
buf[i++] = ((char)wc);
else
i += u8_wc_toutf8(&buf[i], wc);
}
else {
buf[i++] = read_escape_control_char((char)c);
}
}
else {
buf[i++] = c;
}
}
s = cvalue_string(i);
memcpy(cvalue_data(s), buf, i);
free(buf);
return s;
}
