123 lines
2.8 KiB
C
123 lines
2.8 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <limits.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#define B23_BLOCK_SIZE 4096
|
|
|
|
static int
|
|
parse_u64(const char *text, uint64_t *value)
|
|
{
|
|
char *end;
|
|
uintmax_t parsed;
|
|
|
|
errno = 0;
|
|
parsed = strtoumax(text, &end, 10);
|
|
if (errno != 0 || end == text || *end != '\0' || parsed > INT64_MAX)
|
|
return (-1);
|
|
*value = (uint64_t)parsed;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
check_payload(const unsigned char *data)
|
|
{
|
|
size_t index;
|
|
|
|
for (index = 0; index < B23_BLOCK_SIZE; index++) {
|
|
if (data[index] != (unsigned char)((index * 37 + 11) & 0xff))
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
check_pass(int argc, char **argv)
|
|
{
|
|
unsigned char data[B23_BLOCK_SIZE];
|
|
struct stat status;
|
|
uint64_t expected_size, offset;
|
|
ssize_t count;
|
|
int descriptor, index;
|
|
|
|
if (argc < 5 || parse_u64(argv[3], &expected_size) != 0)
|
|
return (2);
|
|
if (stat(argv[2], &status) != 0) {
|
|
perror("stat positive explicit target");
|
|
return (1);
|
|
}
|
|
if ((uint64_t)status.st_size != expected_size) {
|
|
fprintf(stderr, "size mismatch: got=%jd expected=%" PRIu64 "\n",
|
|
(intmax_t)status.st_size, expected_size);
|
|
return (1);
|
|
}
|
|
descriptor = open(argv[2], O_RDONLY);
|
|
if (descriptor < 0) {
|
|
perror("open positive explicit target");
|
|
return (1);
|
|
}
|
|
for (index = 4; index < argc; index++) {
|
|
if (parse_u64(argv[index], &offset) != 0 ||
|
|
offset > expected_size || B23_BLOCK_SIZE > expected_size - offset) {
|
|
fprintf(stderr, "invalid probe offset: %s\n", argv[index]);
|
|
close(descriptor);
|
|
return (2);
|
|
}
|
|
count = pread(descriptor, data, sizeof(data), (off_t)offset);
|
|
if (count != (ssize_t)sizeof(data) || check_payload(data) != 0) {
|
|
fprintf(stderr, "mapped payload mismatch at offset=%" PRIu64
|
|
" count=%zd errno=%d\n", offset, count, errno);
|
|
close(descriptor);
|
|
return (1);
|
|
}
|
|
}
|
|
if (close(descriptor) != 0) {
|
|
perror("close positive explicit target");
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
check_errno(int argc, char **argv)
|
|
{
|
|
struct stat status;
|
|
uint64_t expected;
|
|
|
|
if (argc != 4 || parse_u64(argv[3], &expected) != 0 || expected > INT_MAX)
|
|
return (2);
|
|
errno = 0;
|
|
if (stat(argv[2], &status) == 0) {
|
|
fprintf(stderr, "corrupt explicit target unexpectedly published\n");
|
|
return (1);
|
|
}
|
|
if (errno != (int)expected) {
|
|
fprintf(stderr, "errno mismatch: got=%d expected=%" PRIu64 "\n",
|
|
errno, expected);
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
if (argc >= 2 && strcmp(argv[1], "pass") == 0)
|
|
return (check_pass(argc, argv));
|
|
if (argc >= 2 && strcmp(argv[1], "errno") == 0)
|
|
return (check_errno(argc, argv));
|
|
fprintf(stderr, "usage: %s pass PATH SIZE OFFSET... | errno PATH ERRNO\n",
|
|
argv[0]);
|
|
return (2);
|
|
}
|