/*static*/ status_t
FSUtils::CompareFileContent(BPositionIO& content1, BPositionIO& content2,
bool& _equal)
{
// get and compare content size
off_t size1;
status_t error = content1.GetSize(&size1);
if (error != B_OK)
return error;
off_t size2;
error = content2.GetSize(&size2);
if (error != B_OK)
return error;
if (size1 != size2) {
_equal = false;
return B_OK;
}
if (size1 == 0) {
_equal = true;
return B_OK;
}
// allocate a data buffer
uint8* buffer1 = new(std::nothrow) uint8[2 * kCompareDataBufferSize];
if (buffer1 == NULL)
return B_NO_MEMORY;
ArrayDeleter<uint8> bufferDeleter(buffer1);
uint8* buffer2 = buffer1 + kCompareDataBufferSize;
// compare the data
off_t offset = 0;
while (offset < size1) {
size_t toCompare = std::min(size_t(size1 - offset),
kCompareDataBufferSize);
ssize_t bytesRead = content1.ReadAt(offset, buffer1, toCompare);
if (bytesRead < 0)
return bytesRead;
if ((size_t)bytesRead != toCompare)
return B_ERROR;
bytesRead = content2.ReadAt(offset, buffer2, toCompare);
if (bytesRead < 0)
return bytesRead;
if ((size_t)bytesRead != toCompare)
return B_ERROR;
if (memcmp(buffer1, buffer2, toCompare) != 0) {
_equal = false;
return B_OK;
}
offset += bytesRead;
}
_equal = true;
return B_OK;
}
static status_t
GetDefaultGateway(BString& gateway)
{
// TODO: This method is here because BNetworkInterface
// doesn't yet have any route getting methods
int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
if (socket < 0)
return errno;
FileDescriptorCloser fdCloser(socket);
// Obtain gateway
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(socket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return errno;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return B_ERROR;
void* buffer = malloc(size);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(socket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return errno;
ifreq* interface = (ifreq*)buffer;
ifreq* end = (ifreq*)((uint8*)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if ((route.flags & RTF_GATEWAY) != 0) {
sockaddr_in* inetAddress = (sockaddr_in*)route.gateway;
gateway = inet_ntoa(inetAddress->sin_addr);
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
return B_OK;
}
ssize_t
_user_read_dir(int fd, struct dirent* userBuffer, size_t bufferSize,
uint32 maxCount)
{
TRACE(("user_read_dir(fd = %d, userBuffer = %p, bufferSize = %ld, count = "
"%lu)\n", fd, userBuffer, bufferSize, maxCount));
if (maxCount == 0)
return 0;
if (userBuffer == NULL || !IS_USER_ADDRESS(userBuffer))
return B_BAD_ADDRESS;
// get I/O context and FD
io_context* ioContext = get_current_io_context(false);
FDGetter fdGetter;
struct file_descriptor* descriptor = fdGetter.SetTo(ioContext, fd, false);
if (descriptor == NULL || (descriptor->open_mode & O_DISCONNECTED) != 0)
return B_FILE_ERROR;
if (descriptor->ops->fd_read_dir == NULL)
return B_UNSUPPORTED;
// restrict buffer size and allocate a heap buffer
if (bufferSize > kMaxReadDirBufferSize)
bufferSize = kMaxReadDirBufferSize;
struct dirent* buffer = (struct dirent*)malloc(bufferSize);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
// read the directory
uint32 count = maxCount;
status_t status = descriptor->ops->fd_read_dir(ioContext, descriptor,
buffer, bufferSize, &count);
if (status != B_OK)
return status;
// copy the buffer back -- determine the total buffer size first
size_t sizeToCopy = 0;
struct dirent* entry = buffer;
for (uint32 i = 0; i < count; i++) {
size_t length = entry->d_reclen;
sizeToCopy += length;
entry = (struct dirent*)((uint8*)entry + length);
}
if (user_memcpy(userBuffer, buffer, sizeToCopy) != B_OK)
return B_BAD_ADDRESS;
return count;
}
status_t
PackageFileHeapReader::Init()
{
if (fUncompressedHeapSize == 0)
return B_OK;
// Determine number of chunks and adjust the compressed heap size (subtract
// the size of the chunk size array at the end). Note that the size of the
// last chunk has not been saved, since it size is implied.
ssize_t chunkCount = (fUncompressedHeapSize + kChunkSize - 1) / kChunkSize;
if (chunkCount <= 0)
return B_OK;
fCompressedHeapSize -= (chunkCount - 1) * 2;
// allocate a buffer
uint16* buffer = (uint16*)malloc(kChunkSize);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
// read the chunk size array
size_t remainingChunks = chunkCount - 1;
size_t index = 0;
uint64 offset = fCompressedHeapSize;
while (remainingChunks > 0) {
size_t toRead = std::min(remainingChunks, kChunkSize / 2);
status_t error = ReadFileData(offset, buffer, toRead * 2);
if (error != B_OK)
return error;
if (!fOffsets.InitChunksOffsets(chunkCount, index, buffer, toRead))
return B_NO_MEMORY;
remainingChunks -= toRead;
index += toRead;
offset += toRead * 2;
}
return B_OK;
}
void
ArchitectureX8664::UpdateStackFrameCpuState(const StackFrame* frame,
Image* previousImage, FunctionDebugInfo* previousFunction,
CpuState* previousCpuState)
{
// This is not a top frame, so we want to offset rip to the previous
// (calling) instruction.
CpuStateX8664* cpuState = dynamic_cast<CpuStateX8664*>(previousCpuState);
// get rip
uint64 rip = cpuState->IntRegisterValue(X86_64_REGISTER_RIP);
if (previousFunction == NULL || rip <= previousFunction->Address())
return;
target_addr_t functionAddress = previousFunction->Address();
// allocate a buffer for the function code to disassemble
size_t bufferSize = rip - functionAddress;
void* buffer = malloc(bufferSize);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
// read the code
ssize_t bytesRead = fTeamMemory->ReadMemory(functionAddress, buffer,
bufferSize);
if (bytesRead != (ssize_t)bufferSize)
return;
// disassemble to get the previous instruction
DisassemblerX8664 disassembler;
target_addr_t instructionAddress;
target_size_t instructionSize;
if (disassembler.Init(functionAddress, buffer, bufferSize) == B_OK
&& disassembler.GetPreviousInstruction(rip, instructionAddress,
instructionSize) == B_OK) {
rip -= instructionSize;
cpuState->SetIntRegister(X86_64_REGISTER_RIP, rip);
}
}
status_t
TeamDebugInfo::DisassembleFunction(FunctionInstance* functionInstance,
DisassembledCode*& _sourceCode)
{
// allocate a buffer for the function code
static const target_size_t kMaxBufferSize = 64 * 1024;
target_size_t bufferSize = std::min(functionInstance->Size(),
kMaxBufferSize);
void* buffer = malloc(bufferSize);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
// read the function code
FunctionDebugInfo* functionDebugInfo
= functionInstance->GetFunctionDebugInfo();
ssize_t bytesRead = functionDebugInfo->GetSpecificImageDebugInfo()
->ReadCode(functionInstance->Address(), buffer, bufferSize);
if (bytesRead < 0)
return bytesRead;
return fArchitecture->DisassembleCode(functionDebugInfo, buffer, bytesRead,
_sourceCode);
}
status_t
__find_directory(directory_which which, dev_t device, bool createIt,
char *returnedPath, int32 _pathLength)
{
if (_pathLength <= 0)
return E2BIG;
size_t pathLength = _pathLength;
const char *templatePath = NULL;
/* as with the R5 version, no on-stack buffer */
char *buffer = (char*)malloc(pathLength);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
memset(buffer, 0, pathLength);
strlcat(buffer, "/boot", pathLength);
switch ((int)which) {
/* Haiku system directories */
case B_SYSTEM_DIRECTORY:
case B_BEOS_SYSTEM_DIRECTORY:
case B_SYSTEM_ADDONS_DIRECTORY:
case B_SYSTEM_BOOT_DIRECTORY:
case B_SYSTEM_FONTS_DIRECTORY:
case B_SYSTEM_LIB_DIRECTORY:
case B_SYSTEM_SERVERS_DIRECTORY:
case B_SYSTEM_APPS_DIRECTORY:
case B_SYSTEM_BIN_DIRECTORY:
case B_BEOS_ETC_DIRECTORY:
case B_SYSTEM_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_PREFERENCES_DIRECTORY:
case B_SYSTEM_TRANSLATORS_DIRECTORY:
case B_SYSTEM_MEDIA_NODES_DIRECTORY:
case B_SYSTEM_SOUNDS_DIRECTORY:
case B_SYSTEM_DATA_DIRECTORY:
case B_SYSTEM_DEVELOP_DIRECTORY:
case B_SYSTEM_PACKAGES_DIRECTORY:
case B_SYSTEM_HEADERS_DIRECTORY:
templatePath = kSystemDirectories[which - B_SYSTEM_DIRECTORY];
break;
/* Obsolete common directories and writable system directories */
case B_COMMON_DIRECTORY:
case B_COMMON_SYSTEM_DIRECTORY:
case B_COMMON_ADDONS_DIRECTORY:
case B_COMMON_BOOT_DIRECTORY:
case B_COMMON_FONTS_DIRECTORY:
case B_COMMON_LIB_DIRECTORY:
case B_COMMON_SERVERS_DIRECTORY:
case B_COMMON_BIN_DIRECTORY:
case B_SYSTEM_ETC_DIRECTORY:
case B_COMMON_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_SETTINGS_DIRECTORY:
case B_COMMON_DEVELOP_DIRECTORY:
case B_SYSTEM_LOG_DIRECTORY:
case B_SYSTEM_SPOOL_DIRECTORY:
case B_SYSTEM_TEMP_DIRECTORY:
case B_SYSTEM_VAR_DIRECTORY:
case B_COMMON_TRANSLATORS_DIRECTORY:
case B_COMMON_MEDIA_NODES_DIRECTORY:
case B_COMMON_SOUNDS_DIRECTORY:
case B_COMMON_DATA_DIRECTORY:
case B_SYSTEM_CACHE_DIRECTORY:
case B_COMMON_PACKAGES_DIRECTORY:
case B_COMMON_HEADERS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DIRECTORY:
case B_SYSTEM_NONPACKAGED_ADDONS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_TRANSLATORS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_MEDIA_NODES_DIRECTORY:
case B_SYSTEM_NONPACKAGED_BIN_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DATA_DIRECTORY:
case B_SYSTEM_NONPACKAGED_FONTS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_SOUNDS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_NONPACKAGED_LIB_DIRECTORY:
case B_SYSTEM_NONPACKAGED_HEADERS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DEVELOP_DIRECTORY:
templatePath = kCommonDirectories[which - B_COMMON_DIRECTORY];
break;
/* User directories */
case B_USER_DIRECTORY:
case B_USER_CONFIG_DIRECTORY:
case B_USER_ADDONS_DIRECTORY:
case B_USER_BOOT_DIRECTORY:
case B_USER_FONTS_DIRECTORY:
case B_USER_LIB_DIRECTORY:
case B_USER_SETTINGS_DIRECTORY:
case B_USER_DESKBAR_DIRECTORY:
case B_USER_PRINTERS_DIRECTORY:
case B_USER_TRANSLATORS_DIRECTORY:
case B_USER_MEDIA_NODES_DIRECTORY:
case B_USER_SOUNDS_DIRECTORY:
case B_USER_DATA_DIRECTORY:
case B_USER_CACHE_DIRECTORY:
case B_USER_PACKAGES_DIRECTORY:
case B_USER_HEADERS_DIRECTORY:
case B_USER_DEVELOP_DIRECTORY:
case B_USER_DOCUMENTATION_DIRECTORY:
case B_USER_NONPACKAGED_DIRECTORY:
case B_USER_NONPACKAGED_ADDONS_DIRECTORY:
case B_USER_NONPACKAGED_TRANSLATORS_DIRECTORY:
case B_USER_NONPACKAGED_MEDIA_NODES_DIRECTORY:
case B_USER_NONPACKAGED_BIN_DIRECTORY:
case B_USER_NONPACKAGED_DATA_DIRECTORY:
case B_USER_NONPACKAGED_FONTS_DIRECTORY:
case B_USER_NONPACKAGED_SOUNDS_DIRECTORY:
case B_USER_NONPACKAGED_DOCUMENTATION_DIRECTORY:
case B_USER_NONPACKAGED_LIB_DIRECTORY:
case B_USER_NONPACKAGED_HEADERS_DIRECTORY:
case B_USER_NONPACKAGED_DEVELOP_DIRECTORY:
case B_USER_SERVERS_DIRECTORY:
case B_USER_APPS_DIRECTORY:
case B_USER_BIN_DIRECTORY:
case B_USER_PREFERENCES_DIRECTORY:
case B_USER_ETC_DIRECTORY:
case B_USER_LOG_DIRECTORY:
case B_USER_SPOOL_DIRECTORY:
case B_USER_VAR_DIRECTORY:
templatePath = kUserDirectories[which - B_USER_DIRECTORY];
break;
default:
return EINVAL;
}
if (templatePath == NULL)
return ENOENT;
PathBuffer pathBuffer(buffer, pathLength, strlen(buffer));
// resolve "$h" placeholder to the user's home directory
if (!strncmp(templatePath, "$h", 2)) {
pathBuffer.Append("/home");
templatePath += 2;
} else if (templatePath[0] != '\0')
pathBuffer.Append('/');
// resolve "$a" placeholder to the architecture subdirectory, if not
// primary
if (char* dollar = strchr(templatePath, '$')) {
if (dollar[1] == 'a') {
pathBuffer.Append(templatePath, dollar - templatePath);
templatePath = dollar + 2;
}
}
// append (remainder of) template path
pathBuffer.Append(templatePath);
if (pathBuffer.Length() >= pathLength)
return E2BIG;
strlcpy(returnedPath, buffer, pathLength);
return B_OK;
}
status_t
__find_directory(directory_which which, dev_t device, bool createIt,
char *returnedPath, int32 _pathLength)
{
if (_pathLength <= 0)
return E2BIG;
size_t pathLength = _pathLength;
status_t err = B_OK;
dev_t bootDevice = -1;
struct fs_info fsInfo;
struct stat st;
const char *templatePath = NULL;
/* as with the R5 version, no on-stack buffer */
char *buffer = (char*)malloc(pathLength);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
memset(buffer, 0, pathLength);
/* fiddle with non-boot volume for items that need it */
switch (which) {
case B_DESKTOP_DIRECTORY:
case B_TRASH_DIRECTORY:
bootDevice = dev_for_path("/boot");
if (device <= 0)
device = bootDevice;
if (fs_stat_dev(device, &fsInfo) != B_OK)
return ENODEV;
if (device != bootDevice) {
#ifdef _KERNEL_MODE
err = _user_entry_ref_to_path(device, fsInfo.root, /*"."*/
NULL, buffer, pathLength);
#else
err = _kern_entry_ref_to_path(device, fsInfo.root, /*"."*/
NULL, buffer, pathLength);
#endif
if (err != B_OK)
return err;
} else {
/* use the user id to find the home folder */
/* done later */
strlcat(buffer, "/boot", pathLength);
}
break;
case B_PACKAGE_LINKS_DIRECTORY:
// this is a directory living in rootfs
break;
default:
strlcat(buffer, "/boot", pathLength);
break;
}
switch ((int)which) {
/* Per volume directories */
case B_DESKTOP_DIRECTORY:
if (device == bootDevice || !strcmp(fsInfo.fsh_name, "bfs"))
templatePath = "$h/Desktop";
break;
case B_TRASH_DIRECTORY:
// TODO: eventually put that into the file system API?
if (device == bootDevice || !strcmp(fsInfo.fsh_name, "bfs"))
templatePath = "trash"; // TODO: add suffix for current user
else if (!strcmp(fsInfo.fsh_name, "fat"))
templatePath = "RECYCLED/_BEOS_";
break;
/* Haiku system directories */
case B_SYSTEM_DIRECTORY:
case B_BEOS_SYSTEM_DIRECTORY:
case B_SYSTEM_ADDONS_DIRECTORY:
case B_SYSTEM_BOOT_DIRECTORY:
case B_SYSTEM_FONTS_DIRECTORY:
case B_SYSTEM_LIB_DIRECTORY:
case B_SYSTEM_SERVERS_DIRECTORY:
case B_SYSTEM_APPS_DIRECTORY:
case B_SYSTEM_BIN_DIRECTORY:
case B_BEOS_ETC_DIRECTORY:
case B_SYSTEM_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_PREFERENCES_DIRECTORY:
case B_SYSTEM_TRANSLATORS_DIRECTORY:
case B_SYSTEM_MEDIA_NODES_DIRECTORY:
case B_SYSTEM_SOUNDS_DIRECTORY:
case B_SYSTEM_DATA_DIRECTORY:
case B_SYSTEM_DEVELOP_DIRECTORY:
case B_SYSTEM_PACKAGES_DIRECTORY:
case B_SYSTEM_HEADERS_DIRECTORY:
templatePath = kSystemDirectories[which - B_SYSTEM_DIRECTORY];
break;
/* Obsolete common directories and writable system directories */
case B_COMMON_DIRECTORY:
case B_COMMON_SYSTEM_DIRECTORY:
case B_COMMON_ADDONS_DIRECTORY:
case B_COMMON_BOOT_DIRECTORY:
case B_COMMON_FONTS_DIRECTORY:
case B_COMMON_LIB_DIRECTORY:
case B_COMMON_SERVERS_DIRECTORY:
case B_COMMON_BIN_DIRECTORY:
case B_SYSTEM_ETC_DIRECTORY:
case B_COMMON_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_SETTINGS_DIRECTORY:
case B_COMMON_DEVELOP_DIRECTORY:
case B_SYSTEM_LOG_DIRECTORY:
case B_SYSTEM_SPOOL_DIRECTORY:
case B_SYSTEM_TEMP_DIRECTORY:
case B_SYSTEM_VAR_DIRECTORY:
case B_COMMON_TRANSLATORS_DIRECTORY:
case B_COMMON_MEDIA_NODES_DIRECTORY:
case B_COMMON_SOUNDS_DIRECTORY:
case B_COMMON_DATA_DIRECTORY:
case B_SYSTEM_CACHE_DIRECTORY:
case B_COMMON_PACKAGES_DIRECTORY:
case B_COMMON_HEADERS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DIRECTORY:
case B_SYSTEM_NONPACKAGED_ADDONS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_TRANSLATORS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_MEDIA_NODES_DIRECTORY:
case B_SYSTEM_NONPACKAGED_BIN_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DATA_DIRECTORY:
case B_SYSTEM_NONPACKAGED_FONTS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_SOUNDS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DOCUMENTATION_DIRECTORY:
case B_SYSTEM_NONPACKAGED_LIB_DIRECTORY:
case B_SYSTEM_NONPACKAGED_HEADERS_DIRECTORY:
case B_SYSTEM_NONPACKAGED_DEVELOP_DIRECTORY:
templatePath = kCommonDirectories[which - B_COMMON_DIRECTORY];
break;
/* User directories */
case B_USER_DIRECTORY:
case B_USER_CONFIG_DIRECTORY:
case B_USER_ADDONS_DIRECTORY:
case B_USER_BOOT_DIRECTORY:
case B_USER_FONTS_DIRECTORY:
case B_USER_LIB_DIRECTORY:
case B_USER_SETTINGS_DIRECTORY:
case B_USER_DESKBAR_DIRECTORY:
case B_USER_PRINTERS_DIRECTORY:
case B_USER_TRANSLATORS_DIRECTORY:
case B_USER_MEDIA_NODES_DIRECTORY:
case B_USER_SOUNDS_DIRECTORY:
case B_USER_DATA_DIRECTORY:
case B_USER_CACHE_DIRECTORY:
case B_USER_PACKAGES_DIRECTORY:
case B_USER_HEADERS_DIRECTORY:
case B_USER_DEVELOP_DIRECTORY:
case B_USER_DOCUMENTATION_DIRECTORY:
case B_USER_NONPACKAGED_DIRECTORY:
case B_USER_NONPACKAGED_ADDONS_DIRECTORY:
case B_USER_NONPACKAGED_TRANSLATORS_DIRECTORY:
case B_USER_NONPACKAGED_MEDIA_NODES_DIRECTORY:
case B_USER_NONPACKAGED_BIN_DIRECTORY:
case B_USER_NONPACKAGED_DATA_DIRECTORY:
case B_USER_NONPACKAGED_FONTS_DIRECTORY:
case B_USER_NONPACKAGED_SOUNDS_DIRECTORY:
case B_USER_NONPACKAGED_DOCUMENTATION_DIRECTORY:
case B_USER_NONPACKAGED_LIB_DIRECTORY:
case B_USER_NONPACKAGED_HEADERS_DIRECTORY:
case B_USER_NONPACKAGED_DEVELOP_DIRECTORY:
case B_USER_SERVERS_DIRECTORY:
case B_USER_APPS_DIRECTORY:
case B_USER_BIN_DIRECTORY:
case B_USER_PREFERENCES_DIRECTORY:
case B_USER_ETC_DIRECTORY:
case B_USER_LOG_DIRECTORY:
case B_USER_SPOOL_DIRECTORY:
case B_USER_VAR_DIRECTORY:
templatePath = kUserDirectories[which - B_USER_DIRECTORY];
break;
/* Global directories */
case B_APPS_DIRECTORY:
case B_UTILITIES_DIRECTORY:
templatePath = SYSTEM "/apps";
break;
case B_PREFERENCES_DIRECTORY:
templatePath = SYSTEM "/preferences";
break;
case B_PACKAGE_LINKS_DIRECTORY:
templatePath = "packages";
break;
default:
return EINVAL;
}
if (templatePath == NULL)
return ENOENT;
PathBuffer pathBuffer(buffer, pathLength, strlen(buffer));
// resolve "$h" placeholder to the user's home directory
if (!strncmp(templatePath, "$h", 2)) {
if (bootDevice > -1 && device != bootDevice) {
pathBuffer.Append("/home");
} else {
size_t length = get_user_home_path(buffer, pathLength);
if (length >= pathLength)
return E2BIG;
pathBuffer.SetTo(buffer, pathLength, length);
}
templatePath += 2;
} else if (templatePath[0] != '\0')
pathBuffer.Append('/');
// resolve "$a" placeholder to the architecture subdirectory, if not
// primary
if (char* dollar = strchr(templatePath, '$')) {
if (dollar[1] == 'a') {
pathBuffer.Append(templatePath, dollar - templatePath);
#ifndef _KERNEL_MODE
const char* architecture = __get_architecture();
if (strcmp(architecture, __get_primary_architecture()) != 0) {
pathBuffer.Append('/');
pathBuffer.Append(architecture);
}
#endif
templatePath = dollar + 2;
}
}
// append (remainder of) template path
pathBuffer.Append(templatePath);
if (pathBuffer.Length() >= pathLength)
return E2BIG;
if (createIt && stat(buffer, &st) < 0) {
err = create_path(buffer, 0755);
if (err != B_OK)
return err;
}
strlcpy(returnedPath, buffer, pathLength);
return B_OK;
}
void
Setting::ReadConfiguration()
{
ifreq request;
if (!_PrepareRequest(request))
return;
BString text = "dummy";
char address[32];
sockaddr_in* inetAddress = NULL;
// Obtain IP.
if (ioctl(fSocket, SIOCGIFADDR, &request, sizeof(request)) < 0)
return;
inetAddress = (sockaddr_in*)&request.ifr_addr;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fIP = address;
// Obtain netmask.
if (ioctl(fSocket, SIOCGIFNETMASK, &request,
sizeof(request)) < 0) {
return;
}
inetAddress = (sockaddr_in*)&request.ifr_mask;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fNetmask = address;
// Obtain gateway
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(fSocket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
void *buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fSocket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return;
ifreq *interface = (ifreq *)buffer;
ifreq *end = (ifreq *)((uint8 *)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if (route.flags & RTF_GATEWAY) {
inetAddress = (sockaddr_in*)route.gateway;
fGateway = inet_ntoa(inetAddress->sin_addr);
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
uint32 flags = 0;
if (ioctl(fSocket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0)
flags = request.ifr_flags;
fAuto = (flags & IFF_AUTO_CONFIGURED) != 0;
fEnabled = (flags & IFF_UP) != 0;
if (ioctl(fSocket, SIOCGIFMEDIA, &request, sizeof(struct ifreq)) == 0)
fMedia = request.ifr_media;
// read resolv.conf for the dns.
fNameservers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameservers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
}
}
void
Setting::ReadConfiguration()
{
ifreq request;
if (!_PrepareRequest(request))
return;
BString text = "dummy";
char address[32];
sockaddr_in* inetAddress = NULL;
// Obtain IP.
if (ioctl(fSocket, SIOCGIFADDR, &request, sizeof(request)) < 0)
return;
inetAddress = (sockaddr_in*)&request.ifr_addr;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fIP = address;
// Obtain netmask.
if (ioctl(fSocket, SIOCGIFNETMASK, &request,
sizeof(request)) < 0) {
return;
}
inetAddress = (sockaddr_in*)&request.ifr_mask;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fNetmask = address;
// Obtain gateway
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(fSocket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
void *buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fSocket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return;
ifreq *interface = (ifreq *)buffer;
ifreq *end = (ifreq *)((uint8 *)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if (route.flags & RTF_GATEWAY) {
inetAddress = (sockaddr_in*)route.gateway;
fGateway = inet_ntoa(inetAddress->sin_addr);
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface +
IF_NAMESIZE + sizeof(route_entry) + addressSize);
}
uint32 flags = 0;
if (ioctl(fSocket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0)
flags = request.ifr_flags;
fAuto = flags & IFF_AUTO_CONFIGURED;
if (ioctl(fSocket, SIOCGIFMEDIA, &request, sizeof(struct ifreq)) == 0)
fMedia = request.ifr_media;
// read resolv.conf for the dns.
fNameservers.MakeEmpty();
#define MATCH(line, name) \
(!strncmp(line, name, sizeof(name) - 1) && \
(line[sizeof(name) - 1] == ' ' || \
line[sizeof(name) - 1] == '\t'))
register FILE *fp = fopen("/etc/resolv.conf", "r");
if (fp == NULL) {
fprintf(stderr, "failed to open '/etc/resolv.conf' to "
"read nameservers: %s\n", strerror(errno));
return;
}
int nserv = 0;
char buf[1024];
register char *cp; //, **pp;
// register int n;
int MAXNS = 2;
// read the config file
while (fgets(buf, sizeof(buf), fp) != NULL) {
// skip comments
if (*buf == ';' || *buf == '#')
continue;
// read nameservers to query
if (MATCH(buf, "nameserver") && nserv < MAXNS) {
// char sbuf[2];
cp = buf + sizeof("nameserver") - 1;
while (*cp == ' ' || *cp == '\t')
cp++;
cp[strcspn(cp, ";# \t\n")] = '\0';
if ((*cp != '\0') && (*cp != '\n')) {
fNameservers.AddItem(new BString(cp));
nserv++;
}
}
continue;
}
fclose(fp);
}
/*! ReadConfiguration pulls the current interface settings
from the interfaces via BNetworkInterface and friends
and populates this classes private settings BAddresses
with them.
*/
void
NetworkSettings::ReadConfiguration()
{
fDisabled = (fNetworkInterface->Flags() & IFF_UP) == 0;
for (int index = 0; index < MAX_PROTOCOLS; index++) {
int inet_id = fProtocols[index].inet_id;
if (fProtocols[index].present) {
// --- Obtain IP Addresses
int32 zeroAddr = fNetworkInterface->FindFirstAddress(inet_id);
if (zeroAddr >= 0) {
fNetworkInterface->GetAddressAt(zeroAddr,
fInterfaceAddressMap[inet_id]);
fAddress[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Address());
fNetmask[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Mask());
}
// --- Obtain gateway
// TODO : maybe in the future no ioctls?
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
// Populate config with size of routing table
if (ioctl(fProtocols[index].socket_id, SIOCGRTSIZE,
&config, sizeof(config)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
// Malloc a buffer the size of the routing table
void* buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fProtocols[index].socket_id, SIOCGRTTABLE,
&config, sizeof(config)) < 0)
return;
ifreq* interface = (ifreq*)buffer;
ifreq* end = (ifreq*)((uint8*)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if ((route.flags & RTF_GATEWAY) != 0) {
if (inet_id == AF_INET) {
char addressOut[INET_ADDRSTRLEN];
sockaddr_in* socketAddr
= (sockaddr_in*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin_addr,
addressOut, INET_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else if (inet_id == AF_INET6) {
char addressOut[INET6_ADDRSTRLEN];
sockaddr_in6* socketAddr
= (sockaddr_in6*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin6_addr,
addressOut, INET6_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else {
printf("Cannot pull routes for unknown protocol: %d\n",
inet_id);
fGateway[inet_id].SetTo("");
}
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
// --- Obtain selfconfiguration options
// TODO : This needs to be determined by protocol flags
// AutoConfiguration on the IP level doesn't exist yet
// ( fInterfaceAddressMap[AF_INET].Flags() )
if (fProtocols[index].socket_id >= 0) {
fAutoConfigure[inet_id] = (fNetworkInterface->Flags()
& (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
}
}
}
// Read wireless network from interfaces
fWirelessNetwork.SetTo(NULL);
BPath path;
find_directory(B_SYSTEM_SETTINGS_DIRECTORY, &path);
path.Append("network");
path.Append("interfaces");
void* handle = load_driver_settings(path.Path());
if (handle != NULL) {
const driver_settings* settings = get_driver_settings(handle);
if (settings != NULL) {
for (int32 i = 0; i < settings->parameter_count; i++) {
driver_parameter& top = settings->parameters[i];
if (!strcmp(top.name, "interface")) {
// The name of the interface can either be the value of
// the "interface" parameter, or a separate "name" parameter
const char* name = NULL;
if (top.value_count > 0) {
name = top.values[0];
if (fName != name)
continue;
}
// search "network" parameter
for (int32 j = 0; j < top.parameter_count; j++) {
driver_parameter& sub = top.parameters[j];
if (name == NULL && !strcmp(sub.name, "name")
&& sub.value_count > 0) {
name = sub.values[0];
if (fName != sub.values[0])
break;
}
if (!strcmp(sub.name, "network")
&& sub.value_count > 0) {
fWirelessNetwork.SetTo(sub.values[0]);
break;
}
}
// We found our interface
if (fName == name)
break;
}
}
}
unload_driver_settings(handle);
}
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
static status_t
device_write(void* cookie, off_t position, const void* data, size_t* numBytes)
{
if (position != 0)
return B_BAD_VALUE;
// copy data to stack buffer
char* buffer = (char*)malloc(*numBytes + 1);
if (buffer == NULL)
return B_NO_MEMORY;
MemoryDeleter bufferDeleter(buffer);
Thread* thread = thread_get_current_thread();
if ((thread->flags & THREAD_FLAGS_SYSCALL) != 0) {
if (!IS_USER_ADDRESS(data)
|| user_memcpy(buffer, data, *numBytes) != B_OK) {
return B_BAD_ADDRESS;
}
} else
memcpy(buffer, data, *numBytes);
buffer[*numBytes] = '\0';
// create an output
TestOutput* output = new(std::nothrow) DebugTestOutput;
if (output == NULL)
return B_NO_MEMORY;
ObjectDeleter<TestOutput> outputDeleter(output);
// parse arguments
char** argv;
int argc;
if (!parse_command_line(buffer, argv, argc))
return B_NO_MEMORY;
ArrayDeleter<char*> argvDeleter(argv);
if (argc == 0)
return B_BAD_VALUE;
// execute command
if (strcmp(argv[0], "help") == 0) {
// print usage -- print individual lines to avoid dprintf() buffer
// overflows
const char* usage = kUsage;
while (*usage != '\0') {
const char* lineEnd = strchr(usage, '\n');
if (lineEnd != NULL)
lineEnd++;
else
lineEnd = usage + strlen(usage);
output->Print("%.*s", (int)(lineEnd - usage), usage);
usage = lineEnd;
}
} else if (strcmp(argv[0], "list") == 0) {
sTestManager->ListTests(*output);
} else if (strcmp(argv[0], "run") == 0) {
// parse options
TestOptions options;
int argi = 1;
while (argi < argc) {
const char* arg = argv[argi];
if (*arg == '-') {
for (arg++; *arg != '\0'; arg++) {
switch (*arg) {
case 'p':
options.panicOnFailure = true;
break;
case 'q':
options.quitAfterFailure = true;
break;
default:
output->Print("Invalid option: \"-%c\"\n", *arg);
return B_BAD_VALUE;
}
}
argi++;
} else
break;
}
GlobalTestContext globalContext(*output, options);
sTestManager->RunTests(globalContext, argv + argi, argc - argi);
} else {
output->Print("Invalid command \"%s\"!\n", argv[0]);
return B_BAD_VALUE;
}
return B_OK;
}
