/*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; }