int main() {
int errno = ERROR_NONE;
k_size_t size = 0;
_kern_read(SH_ROOT_STREAM, 0, &size);
_kern_printf("%i\n", size);
void *buffer = _kern_malloc(size);
if((errno = _kern_read(SH_ROOT_STREAM, buffer, &size)) == ERROR_NONE) {
_kern_printf("directory stream of size: %i read\n", size);
struct stream_entry *entry = (struct stream_entry *)buffer;
while(entry->stream_name[0] != 0x00) {
_kern_printf("%s\n", entry->stream_name);
entry++;
}
} else {
_kern_printf("error code: %i\n", errno);
}
_kern_free(buffer);
return ERROR_NONE;
}
ssize_t
read(int fd, void* buffer, size_t bufferSize)
{
ssize_t status = _kern_read(fd, -1, buffer, bufferSize);
RETURN_AND_SET_ERRNO(status);
}
/*! \brief Reads a number of bytes from the file into a buffer.
\param buffer the buffer the data from the file shall be written to
\param size the number of bytes that shall be read
\return the number of bytes actually read or an error code
*/
ssize_t
BFile::Read(void *buffer, size_t size)
{
if (InitCheck() != B_OK)
return InitCheck();
return _kern_read(get_fd(), -1, buffer, size);
}
/*! \brief Reads a number of bytes from a certain position within the file
into a buffer.
\param location the position (in bytes) within the file from which the
data shall be read
\param buffer the buffer the data from the file shall be written to
\param size the number of bytes that shall be read
\return the number of bytes actually read or an error code
*/
ssize_t
BFile::ReadAt(off_t location, void *buffer, size_t size)
{
if (InitCheck() != B_OK)
return InitCheck();
if (location < 0)
return B_BAD_VALUE;
return _kern_read(get_fd(), location, buffer, size);
}
ssize_t
pread(int fd, void* buffer, size_t bufferSize, off_t pos)
{
ssize_t status;
if (pos < 0) {
errno = B_BAD_VALUE;
return -1;
}
status = _kern_read(fd, pos, buffer, bufferSize);
RETURN_AND_SET_ERRNO(status);
}
static int
fuse_read(const char* path, char* buf, size_t size, off_t offset,
struct fuse_file_info* fi)
{
PRINTD("##read\n");
int fd = _kern_open(-1, path, FSSH_O_RDONLY,
(FSSH_S_IRWXU | FSSH_S_IRWXG | FSSH_S_IRWXO) & ~sUmask);
if (fd < FSSH_B_OK)
return _ERR(fd);
int res = _kern_read(fd, offset, buf, size);
_kern_close(fd);
if (res < FSSH_B_OK)
res = _ERR(res);
return res;
}
static bool
analyze_object_gcc_version(int fd, image_t* image, elf_ehdr& eheader,
int32 sheaderSize, char* buffer, size_t bufferSize)
{
if (sheaderSize > (int)bufferSize) {
FATAL("%s: Cannot handle section headers bigger than %lu bytes\n",
image->path, bufferSize);
return false;
}
// read section headers
ssize_t length = _kern_read(fd, eheader.e_shoff, buffer, sheaderSize);
if (length != sheaderSize) {
FATAL("%s: Could not read section headers: %s\n", image->path,
strerror(length));
return false;
}
// load the string section
elf_shdr* sectionHeader
= (elf_shdr*)(buffer + eheader.e_shstrndx * eheader.e_shentsize);
if (sheaderSize + sectionHeader->sh_size > bufferSize) {
FATAL("%s: Buffer not big enough for section string section\n",
image->path);
return false;
}
char* sectionStrings = buffer + bufferSize - sectionHeader->sh_size;
length = _kern_read(fd, sectionHeader->sh_offset, sectionStrings,
sectionHeader->sh_size);
if (length != (int)sectionHeader->sh_size) {
FATAL("%s: Could not read section string section: %s\n", image->path,
strerror(length));
return false;
}
// find the .comment section
off_t commentOffset = 0;
size_t commentSize = 0;
for (uint32 i = 0; i < eheader.e_shnum; i++) {
sectionHeader = (elf_shdr*)(buffer + i * eheader.e_shentsize);
const char* sectionName = sectionStrings + sectionHeader->sh_name;
if (sectionHeader->sh_name != 0
&& strcmp(sectionName, ".comment") == 0) {
commentOffset = sectionHeader->sh_offset;
commentSize = sectionHeader->sh_size;
break;
}
}
if (commentSize == 0) {
FATAL("%s: Could not find .comment section\n", image->path);
return false;
}
// read a part of the comment section
if (commentSize > 512)
commentSize = 512;
length = _kern_read(fd, commentOffset, buffer, commentSize);
if (length != (int)commentSize) {
FATAL("%s: Could not read .comment section: %s\n", image->path,
strerror(length));
return false;
}
// the common prefix of the strings in the .comment section
static const char* kGCCVersionPrefix = "GCC: (";
size_t gccVersionPrefixLen = strlen(kGCCVersionPrefix);
size_t index = 0;
int gccMajor = 0;
int gccMiddle = 0;
int gccMinor = 0;
bool isHaiku = true;
// Read up to 10 comments. The first three or four are usually from the
// glue code.
for (int i = 0; i < 10; i++) {
// skip '\0'
while (index < commentSize && buffer[index] == '\0')
index++;
char* stringStart = buffer + index;
// find string end
while (index < commentSize && buffer[index] != '\0')
index++;
// ignore the entry at the end of the buffer
if (index == commentSize)
break;
// We have to analyze string like these:
// GCC: (GNU) 2.9-beos-991026
// GCC: (GNU) 2.95.3-haiku-080322
// GCC: (GNU) 4.1.2
// GCC: (2016_02_29) 5.3.0
// FIXME this does not handle binaries generated with clang or other
// compilers.
// skip the common prefix
if (strncmp(stringStart, kGCCVersionPrefix, gccVersionPrefixLen) != 0)
continue;
// Skip the build identifier, the closing parenthesis, and the space
// that follows it.
// Hopefully no one is going to include nested parentheses in the
// version string, so we can save the need for a smarter parser.
char* gccVersion = strchr(stringStart + gccVersionPrefixLen, ')') + 2;
// the rest is the GCC version
char* gccPlatform = strchr(gccVersion, '-');
char* patchLevel = NULL;
if (gccPlatform != NULL) {
*gccPlatform = '\0';
gccPlatform++;
patchLevel = strchr(gccPlatform, '-');
if (patchLevel != NULL) {
*patchLevel = '\0';
patchLevel++;
}
}
// split the gcc version into major, middle, and minor
int version[3] = { 0, 0, 0 };
for (int k = 0; gccVersion != NULL && k < 3; k++) {
char* dot = strchr(gccVersion, '.');
if (dot) {
*dot = '\0';
dot++;
}
version[k] = atoi(gccVersion);
gccVersion = dot;
}
// got any version?
if (version[0] == 0)
continue;
// Select the gcc version with the smallest major, but the greatest
// middle/minor. This should usually ignore the glue code version as
// well as cases where e.g. in a gcc 2 program a single C file has
// been compiled with gcc 4.
if (gccMajor == 0 || gccMajor > version[0]
|| (gccMajor == version[0]
&& (gccMiddle < version[1]
|| (gccMiddle == version[1] && gccMinor < version[2])))) {
gccMajor = version[0];
gccMiddle = version[1];
gccMinor = version[2];
}
if (gccMajor == 2 && gccPlatform != NULL
&& strcmp(gccPlatform, "haiku")) {
isHaiku = false;
}
}
if (gccMajor == 0)
return false;
if (gccMajor == 2) {
if (gccMiddle < 95)
image->abi = B_HAIKU_ABI_GCC_2_ANCIENT;
else if (isHaiku)
image->abi = B_HAIKU_ABI_GCC_2_HAIKU;
else
image->abi = B_HAIKU_ABI_GCC_2_BEOS;
} else {
if (gccMajor == 5) {
// The ABI changes in GCC 5 are optional, and currently we are using
// it in backwards compatible mode. So, it is still generating ABI
// version 4.
gccMajor = 4;
}
image->abi = gccMajor << 16;
}
return true;
}
status_t
load_image(char const* name, image_type type, const char* rpath,
const char* requestingObjectPath, image_t** _image)
{
int32 pheaderSize, sheaderSize;
char path[PATH_MAX];
ssize_t length;
char pheaderBuffer[4096];
int32 numRegions;
image_t* found;
image_t* image;
status_t status;
int fd;
elf_ehdr eheader;
// Have we already loaded that image? Don't check for add-ons -- we always
// reload them.
if (type != B_ADD_ON_IMAGE) {
found = find_loaded_image_by_name(name, APP_OR_LIBRARY_TYPE);
if (found == NULL && type != B_APP_IMAGE && gProgramImage != NULL) {
// Special case for add-ons that link against the application
// executable, with the executable not having a soname set.
if (const char* lastSlash = strrchr(name, '/')) {
if (strcmp(gProgramImage->name, lastSlash + 1) == 0)
found = gProgramImage;
}
}
if (found) {
atomic_add(&found->ref_count, 1);
*_image = found;
KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\") "
"already loaded", name, type, rpath);
return B_OK;
}
}
KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\")", name, type,
rpath);
strlcpy(path, name, sizeof(path));
// find and open the file
fd = open_executable(path, type, rpath, get_program_path(),
requestingObjectPath, sSearchPathSubDir);
if (fd < 0) {
FATAL("Cannot open file %s: %s\n", name, strerror(fd));
KTRACE("rld: load_container(\"%s\"): failed to open file", name);
return fd;
}
// normalize the image path
status = _kern_normalize_path(path, true, path);
if (status != B_OK)
goto err1;
// Test again if this image has been registered already - this time,
// we can check the full path, not just its name as noted.
// You could end up loading an image twice with symbolic links, else.
if (type != B_ADD_ON_IMAGE) {
found = find_loaded_image_by_name(path, APP_OR_LIBRARY_TYPE);
if (found) {
atomic_add(&found->ref_count, 1);
*_image = found;
_kern_close(fd);
KTRACE("rld: load_container(\"%s\"): already loaded after all",
name);
return B_OK;
}
}
length = _kern_read(fd, 0, &eheader, sizeof(eheader));
if (length != sizeof(eheader)) {
status = B_NOT_AN_EXECUTABLE;
FATAL("%s: Troubles reading ELF header\n", path);
goto err1;
}
status = parse_elf_header(&eheader, &pheaderSize, &sheaderSize);
if (status < B_OK) {
FATAL("%s: Incorrect ELF header\n", path);
goto err1;
}
// ToDo: what to do about this restriction??
if (pheaderSize > (int)sizeof(pheaderBuffer)) {
FATAL("%s: Cannot handle program headers bigger than %lu\n",
path, sizeof(pheaderBuffer));
status = B_UNSUPPORTED;
goto err1;
}
length = _kern_read(fd, eheader.e_phoff, pheaderBuffer, pheaderSize);
if (length != pheaderSize) {
FATAL("%s: Could not read program headers: %s\n", path,
strerror(length));
status = B_BAD_DATA;
goto err1;
}
numRegions = count_regions(path, pheaderBuffer, eheader.e_phnum,
eheader.e_phentsize);
if (numRegions <= 0) {
FATAL("%s: Troubles parsing Program headers, numRegions = %" B_PRId32
"\n", path, numRegions);
status = B_BAD_DATA;
goto err1;
}
image = create_image(name, path, numRegions);
if (image == NULL) {
FATAL("%s: Failed to allocate image_t object\n", path);
status = B_NO_MEMORY;
goto err1;
}
status = parse_program_headers(image, pheaderBuffer, eheader.e_phnum,
eheader.e_phentsize);
if (status < B_OK)
goto err2;
if (!assert_dynamic_loadable(image)) {
FATAL("%s: Dynamic segment must be loadable (implementation "
"restriction)\n", image->path);
status = B_UNSUPPORTED;
goto err2;
}
status = map_image(fd, path, image, eheader.e_type == ET_EXEC);
if (status < B_OK) {
FATAL("%s: Could not map image: %s\n", image->path, strerror(status));
status = B_ERROR;
goto err2;
}
if (!parse_dynamic_segment(image)) {
FATAL("%s: Troubles handling dynamic section\n", image->path);
status = B_BAD_DATA;
goto err3;
}
if (eheader.e_entry != 0)
image->entry_point = eheader.e_entry + image->regions[0].delta;
analyze_image_haiku_version_and_abi(fd, image, eheader, sheaderSize,
pheaderBuffer, sizeof(pheaderBuffer));
// If this is the executable image, we init the search path
// subdir, if the compiler version doesn't match ours.
if (type == B_APP_IMAGE) {
#if __GNUC__ == 2
if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_4)
sSearchPathSubDir = "x86";
#elif __GNUC__ >= 4
if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_2)
sSearchPathSubDir = "x86_gcc2";
#endif
}
set_abi_version(image->abi);
// init gcc version dependent image flags
// symbol resolution strategy
if (image->abi == B_HAIKU_ABI_GCC_2_ANCIENT)
image->find_undefined_symbol = find_undefined_symbol_beos;
// init version infos
status = init_image_version_infos(image);
image->type = type;
register_image(image, fd, path);
image_event(image, IMAGE_EVENT_LOADED);
_kern_close(fd);
enqueue_loaded_image(image);
*_image = image;
KTRACE("rld: load_container(\"%s\"): done: id: %" B_PRId32 " (ABI: %#"
B_PRIx32 ")", name, image->id, image->abi);
return B_OK;
err3:
unmap_image(image);
err2:
delete_image_struct(image);
err1:
_kern_close(fd);
KTRACE("rld: load_container(\"%s\"): failed: %s", name,
strerror(status));
return status;
}
/*!
Tests if there is an executable file at the provided path. It will
also test if the file has a valid ELF header or is a shell script.
Even if the runtime loader does not need to be able to deal with
both types, the caller will give scripts a proper treatment.
*/
status_t
test_executable(const char *name, char *invoker)
{
char path[B_PATH_NAME_LENGTH];
char buffer[B_FILE_NAME_LENGTH];
// must be large enough to hold the ELF header
status_t status;
ssize_t length;
int fd;
if (name == NULL)
return B_BAD_VALUE;
strlcpy(path, name, sizeof(path));
fd = open_executable(path, B_APP_IMAGE, NULL, NULL, NULL);
if (fd < B_OK)
return fd;
// see if it's executable at all
status = _kern_access(-1, path, X_OK, false);
if (status != B_OK)
goto out;
// read and verify the ELF header
length = _kern_read(fd, 0, buffer, sizeof(buffer));
if (length < 0) {
status = length;
goto out;
}
status = elf_verify_header(buffer, length);
if (status == B_NOT_AN_EXECUTABLE) {
// test for shell scripts
if (!strncmp(buffer, "#!", 2)) {
char *end;
buffer[min_c((size_t)length, sizeof(buffer) - 1)] = '\0';
end = strchr(buffer, '\n');
if (end == NULL) {
status = E2BIG;
goto out;
} else
end[0] = '\0';
if (invoker)
strcpy(invoker, buffer + 2);
status = B_OK;
}
} else if (status == B_OK) {
elf_ehdr *elfHeader = (elf_ehdr *)buffer;
if (elfHeader->e_entry == 0) {
// we don't like to open shared libraries
status = B_NOT_AN_EXECUTABLE;
} else if (invoker)
invoker[0] = '\0';
}
out:
_kern_close(fd);
return status;
}
