inline bool QStorageIterator::next() { BVolume volume; if (m_volumeRoster.GetNextVolume(&volume) != B_OK) return false; BDirectory directory; if (volume.GetRootDirectory(&directory) != B_OK) return false; const BPath path(&directory); fs_info fsInfo; memset(&fsInfo, 0, sizeof(fsInfo)); if (fs_stat_dev(volume.Device(), &fsInfo) != 0) return false; m_rootPath = path.Path(); m_fileSystemType = QByteArray(fsInfo.fsh_name); const QByteArray deviceName(fsInfo.device_name); m_device = (deviceName.isEmpty() ? QByteArray::number(qint32(volume.Device())) : deviceName); return true; }
void BTrashWatcher::UpdateTrashIcons() { BVolume boot; if (BVolumeRoster().GetBootVolume(&boot) != B_OK) return; BDirectory trashDir; if (FSGetTrashDir(&trashDir, boot.Device()) == B_OK) { // pull out the icons for the current trash state from resources and // apply them onto the trash directory node size_t largeSize = 0; size_t smallSize = 0; const void *largeData = GetTrackerResources()->LoadResource('ICON', fTrashFull ? kResTrashFullIcon : kResTrashIcon, &largeSize); const void *smallData = GetTrackerResources()->LoadResource('MICN', fTrashFull ? kResTrashFullIcon : kResTrashIcon, &smallSize); if (largeData) trashDir.WriteAttr(kAttrLargeIcon, 'ICON', 0, largeData, largeSize); else TRESPASS(); if (smallData) trashDir.WriteAttr(kAttrMiniIcon, 'MICN', 0, smallData, smallSize); else TRESPASS(); } }
void AutoMounter::GetSettings(BMessage *_DEVICE_MAP_ONLY(message)) { #if _INCLUDES_CLASS_DEVICE_MAP message->AddBool("checkRemovableOnly", fScanParams.removableOrUnknownOnly); message->AddBool("checkCDs", fScanParams.checkCDROMs); message->AddBool("checkFloppies", fScanParams.checkFloppies); message->AddBool("checkOtherRemovables", fScanParams.checkOtherRemovable); message->AddBool("autoMountRemovableOnly", fAutomountParams.mountRemovableDisksOnly); message->AddBool("autoMountAll", fAutomountParams.mountAllFS); message->AddBool("autoMountAllBFS", fAutomountParams.mountBFS); message->AddBool("autoMountAllHFS", fAutomountParams.mountHFS); message->AddBool("initialMountAll", fInitialMountAll); message->AddBool("initialMountAllBFS", fInitialMountAllBFS); message->AddBool("initialMountRestore", fInitialMountRestore); message->AddBool("initialMountAllHFS", fInitialMountAllHFS); message->AddBool("suspended", fSuspended); // Save mounted volumes so we can optionally mount them on next // startup BVolumeRoster volumeRoster; BVolume volume; while (volumeRoster.GetNextVolume(&volume) == B_OK) { fs_info info; if (fs_stat_dev(volume.Device(), &info) == 0 && info.flags & (B_FS_IS_REMOVABLE | B_FS_IS_PERSISTENT)) message->AddString(info.device_name, info.volume_name); } #endif }
static char *getMountPoint(const char *devname, char *buf, size_t bufsize) { BVolumeRoster mounts; BVolume vol; mounts.Rewind(); while (mounts.GetNextVolume(&vol) == B_NO_ERROR) { fs_info fsinfo; fs_stat_dev(vol.Device(), &fsinfo); if (strcmp(devname, fsinfo.device_name) == 0) { BDirectory directory; BEntry entry; BPath path; const char *str; if ( (vol.GetRootDirectory(&directory) < B_OK) || (directory.GetEntry(&entry) < B_OK) || (entry.GetPath(&path) < B_OK) || ( (str = path.Path()) == NULL) ) return NULL; strncpy(buf, str, bufsize-1); buf[bufsize-1] = '\0'; return buf; } /* if */ } /* while */ return NULL; } /* getMountPoint */
/*! \brief Finds a BPartition by BVolume. */ status_t BDiskDeviceRoster::FindPartitionByVolume(const BVolume& volume, BDiskDevice* device, BPartition** _partition) { class FindPartitionVisitor : public BDiskDeviceVisitor { public: FindPartitionVisitor(dev_t volume) : fVolume(volume) { } virtual bool Visit(BDiskDevice* device) { return Visit(device, 0); } virtual bool Visit(BPartition* partition, int32 level) { BVolume volume; return partition->GetVolume(&volume) == B_OK && volume.Device() == fVolume; } private: dev_t fVolume; } visitor(volume.Device()); if (VisitEachMountedPartition(&visitor, device, _partition)) return B_OK; return B_ENTRY_NOT_FOUND; }
bool BNavMenu::StartBuildingItemList() { BEntry entry; if (fNavDir.device < 0 || entry.SetTo(&fNavDir) != B_OK || !entry.Exists()) return false; fItemList = new BObjectList<BMenuItem>(50); fIteratingDesktop = false; BDirectory parent; status_t status = entry.GetParent(&parent); // if ref is the root item then build list of volume root dirs fFlags = uint8((fFlags & ~kVolumesOnly) | (status == B_ENTRY_NOT_FOUND ? kVolumesOnly : 0)); if (fFlags & kVolumesOnly) return true; Model startModel(&entry, true); if (startModel.InitCheck() != B_OK || !startModel.IsContainer()) return false; if (startModel.IsQuery()) fContainer = new QueryEntryListCollection(&startModel); else if (FSIsDeskDir(&entry)) { fIteratingDesktop = true; fContainer = DesktopPoseView::InitDesktopDirentIterator(0, startModel.EntryRef()); AddRootItemsIfNeeded(); } else if (FSIsTrashDir(&entry)) { // the trash window needs to display a union of all the // trash folders from all the mounted volumes BVolumeRoster volRoster; volRoster.Rewind(); BVolume volume; fContainer = new EntryIteratorList(); while (volRoster.GetNextVolume(&volume) == B_OK) { if (!volume.IsPersistent()) continue; BDirectory trashDir; if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK) dynamic_cast<EntryIteratorList *>(fContainer)-> AddItem(new DirectoryEntryList(trashDir)); } } else fContainer = new DirectoryEntryList(*dynamic_cast<BDirectory *> (startModel.Node())); if (fContainer == NULL || fContainer->InitCheck() != B_OK) return false; fContainer->Rewind(); return true; }
// get_volume_info bool get_volume_info( BVolume& volume, BString& volumeName, bool& isCDROM, BString& deviceName ) { bool success = false; isCDROM = false; deviceName = ""; volumeName = ""; char name[B_FILE_NAME_LENGTH]; if ( volume.GetName( name ) >= B_OK ) // disk is currently mounted { volumeName = name; dev_t dev = volume.Device(); fs_info info; if ( fs_stat_dev( dev, &info ) == B_OK ) { success = true; deviceName = info.device_name; if ( volume.IsReadOnly() ) { int i_dev = open( info.device_name, O_RDONLY ); if ( i_dev >= 0 ) { device_geometry g; if ( ioctl( i_dev, B_GET_GEOMETRY, &g, sizeof( g ) ) >= 0 ) isCDROM = ( g.device_type == B_CD ); close( i_dev ); } } } } return success; }
int getextmntent_haiku(int* cookie, struct extmnttab *mp, int len) { static BLocker extmntent_locker; extmntent_locker.Lock(); BVolumeRoster roster; BVolume volume; int ret = -1; roster.Rewind(); for (int i = 0; i <= *cookie; i++) if (roster.GetNextVolume(&volume) != B_NO_ERROR) return -1; if (getmntent_haiku(cookie, (struct mnttab*)mp) == 0) { mp->mnt_major = volume.Device(); mp->mnt_minor = volume.Device(); ret = 0; } extmntent_locker.Unlock(); return ret; }
static char *getMountPoint(const char *devname) { BVolumeRoster mounts; BVolume vol; mounts.Rewind(); while (mounts.GetNextVolume(&vol) == B_NO_ERROR) { fs_info fsinfo; fs_stat_dev(vol.Device(), &fsinfo); if (strcmp(devname, fsinfo.device_name) == 0) { //char buf[B_FILE_NAME_LENGTH]; BDirectory directory; BEntry entry; BPath path; status_t rc; rc = vol.GetRootDirectory(&directory); BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL); rc = directory.GetEntry(&entry); BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL); rc = entry.GetPath(&path); BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL); const char *str = path.Path(); BAIL_IF_MACRO(str == NULL, ERR_OS_ERROR, NULL); /* ?! */ char *retval = (char *) allocator.Malloc(strlen(str) + 1); BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); strcpy(retval, str); return(retval); } /* if */ } /* while */ return(NULL); } /* getMountPoint */
status_t CDDBLookup::Lookup(CDDBServer& server, const char* path, bool dumpOnly, bool verbose) { BVolumeRoster roster; BVolume volume; while (roster.GetNextVolume(&volume) == B_OK) { fs_info info; if (fs_stat_dev(volume.Device(), &info) != B_OK) continue; if (strcmp(path, info.device_name) == 0) return Lookup(server, volume.Device(), dumpOnly, verbose); } return B_ENTRY_NOT_FOUND; }
void CDDBLookup::LookupAll(CDDBServer& server, bool dumpOnly, bool verbose) { BVolumeRoster roster; BVolume volume; while (roster.GetNextVolume(&volume) == B_OK) { Lookup(server, volume.Device(), dumpOnly, verbose); } }
void LiveQuery::_AddQuery(BVolume& volume, const char* predicate) { BMessage add(kMsgAddQuery); add.AddInt32("volume", volume.Device()); add.AddString("predicate", predicate); PostMessage(&add); }
status_t TaskFS::SetUpMimeTyp(void) { status_t err; //set the MimeType BMimeType mime(TASK_MIMETYPE); //later do better check bool valid = mime.IsInstalled(); if (!valid) { mime.Install(); mime.SetShortDescription(B_TRANSLATE_CONTEXT("Tasks", "Short mimetype description")); mime.SetLongDescription(B_TRANSLATE_CONTEXT("Tasks", "Long mimetype description")); //get the icon from our Ressources BResources* res = BApplication::AppResources(); if (res != NULL){ size_t size; const void* data = res->LoadResource(B_VECTOR_ICON_TYPE, "TASK_ICON", &size); if (data!=NULL) mime.SetIcon(reinterpret_cast<const uint8*>(data), size); } mime.SetPreferredApp(APP_SIG); // add default task fields to meta-mime type BMessage fields; for (int32 i = 0; sDefaultAttributes[i].attribute; i++) { fields.AddString("attr:public_name", sDefaultAttributes[i].name); fields.AddString("attr:name", sDefaultAttributes[i].attribute); fields.AddInt32("attr:type", sDefaultAttributes[i].type); fields.AddString("attr:display_as", sDefaultAttributes[i].displayAs); fields.AddBool("attr:viewable", sDefaultAttributes[i].isPublic); fields.AddBool("attr:editable", sDefaultAttributes[i].editable); fields.AddInt32("attr:width", sDefaultAttributes[i].width); fields.AddInt32("attr:alignment", B_ALIGN_LEFT); fields.AddBool("attr:extra", false); } mime.SetAttrInfo(&fields); // create indices on all volumes for the found attributes. int32 count = 8; BVolumeRoster volumeRoster; BVolume volume; while (volumeRoster.GetNextVolume(&volume) == B_OK) { for (int32 i = 0; i < count; i++) { if (sDefaultAttributes[i].isPublic == true) fs_create_index(volume.Device(), sDefaultAttributes[i].attribute, sDefaultAttributes[i].type, 0); } } } else err = B_OK; return err; }
status_t CDDBQuery::_OpenContentFile(const int32 &discID) { // Makes sure that the lookup has a valid file to work with for the CD // content. Returns true if there is an existing file, false if a lookup is // required. BFile file; BString predicate; predicate << "CD:key == " << discID; entry_ref ref; BVolumeRoster roster; BVolume volume; roster.Rewind(); while (roster.GetNextVolume(&volume) == B_OK) { if (volume.IsReadOnly() || !volume.IsPersistent() || !volume.KnowsAttr() || !volume.KnowsQuery()) continue; // make sure the volume we are looking at is indexed right fs_create_index(volume.Device(), "CD:key", B_INT32_TYPE, 0); BQuery query; query.SetVolume(&volume); query.SetPredicate(predicate.String()); if (query.Fetch() != B_OK) continue; if (query.GetNextRef(&ref) == B_OK) break; } status_t status = fCDData.Load(ref); if (status == B_NO_INIT) { // We receive this error when the Load() function couldn't load the // track times This just means that we get it from the SCSI data given // to us in SetToCD vector<CDAudioTime> times; GetTrackTimes(&fSCSIData,times); for (int32 i = 0; i < fCDData.CountTracks(); i++) { CDAudioTime *item = fCDData.TrackTimeAt(i); *item = times[i + 1] - times[i]; } status = B_OK; } return status; }
void TTracker::InstallIndices() { BVolumeRoster roster; BVolume volume; roster.Rewind(); while (roster.GetNextVolume(&volume) == B_OK) { if (volume.IsReadOnly() || !volume.IsPersistent() || !volume.KnowsAttr() || !volume.KnowsQuery()) continue; InstallIndices(volume.Device()); } }
void BTrashWatcher::UpdateTrashIcons() { BVolumeRoster roster; BVolume volume; roster.Rewind(); BDirectory trashDir; while (roster.GetNextVolume(&volume) == B_OK) { if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK) { // pull out the icons for the current trash state from resources // and apply them onto the trash directory node size_t largeSize = 0; size_t smallSize = 0; const void* largeData = GetTrackerResources()->LoadResource('ICON', fTrashFull ? R_TrashFullIcon : R_TrashIcon, &largeSize); const void* smallData = GetTrackerResources()->LoadResource('MICN', fTrashFull ? R_TrashFullIcon : R_TrashIcon, &smallSize); #ifdef HAIKU_TARGET_PLATFORM_HAIKU size_t vectorSize = 0; const void* vectorData = GetTrackerResources()->LoadResource( B_VECTOR_ICON_TYPE, fTrashFull ? R_TrashFullIcon : R_TrashIcon, &vectorSize); if (vectorData) { trashDir.WriteAttr(kAttrIcon, B_VECTOR_ICON_TYPE, 0, vectorData, vectorSize); } else TRESPASS(); #endif if (largeData) { trashDir.WriteAttr(kAttrLargeIcon, 'ICON', 0, largeData, largeSize); } else TRESPASS(); if (smallData) { trashDir.WriteAttr(kAttrMiniIcon, 'MICN', 0, smallData, smallSize); } else TRESPASS(); } } }
CDDBDaemon::CDDBDaemon() : BApplication("application/x-vnd.Haiku-cddb_daemon"), fVolumeRoster(new BVolumeRoster) { fVolumeRoster->StartWatching(); BVolume volume; printf("Checking currently mounted volumes ...\n"); while (fVolumeRoster->GetNextVolume(&volume) == B_OK) { if (_Lookup(volume.Device()) != B_OK) { continue; } } printf("Checking complete. Listening for device mounts.\n"); }
void TReplicantTray::InitAddOnSupport() { // list to maintain refs to each rep added/deleted fItemList = new BList(); bool haveKey = false; BPath path; if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, true) == B_OK) { path.Append(kDeskbarSecurityCodeFile); BFile file(path.Path(),B_READ_ONLY); if (file.InitCheck() == B_OK && file.Read(&fDeskbarSecurityCode, sizeof(fDeskbarSecurityCode)) == sizeof(fDeskbarSecurityCode)) haveKey = true; } if (!haveKey) { // create the security code bigtime_t real = real_time_clock_usecs(); bigtime_t boot = system_time(); // two computers would have to have exactly matching clocks, and launch // Deskbar at the exact same time into the bootsequence in order for // their security-ID to be identical fDeskbarSecurityCode = ((real & 0xffffffffULL) << 32) | (boot & 0xffffffffULL); if (find_directory (B_USER_SETTINGS_DIRECTORY, &path, true) == B_OK) { path.Append(kDeskbarSecurityCodeFile); BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE); if (file.InitCheck() == B_OK) file.Write(&fDeskbarSecurityCode, sizeof(fDeskbarSecurityCode)); } } // for each volume currently mounted // index the volume with our indices BVolumeRoster roster; BVolume volume; while (roster.GetNextVolume(&volume) == B_OK) { fs_create_index(volume.Device(), kStatusPredicate, B_STRING_TYPE, 0); RunAddOnQuery(&volume, kEnabledPredicate); } // we also watch for volumes mounted and unmounted watch_node(NULL, B_WATCH_MOUNT | B_WATCH_ATTR, this, Window()); }
void BTrashWatcher::WatchTrashDirs() { BVolumeRoster volRoster; volRoster.Rewind(); BVolume volume; while (volRoster.GetNextVolume(&volume) == B_OK) { if (volume.IsReadOnly() || !volume.IsPersistent()) continue; BDirectory trashDir; if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK) { node_ref trash_node; trashDir.GetNodeRef(&trash_node); watch_node(&trash_node, B_WATCH_DIRECTORY, this); fTrashNodeList.AddItem(new node_ref(trash_node)); } } }
bool BTrashWatcher::CheckTrashDirs() { BVolumeRoster volRoster; volRoster.Rewind(); BVolume volume; while (volRoster.GetNextVolume(&volume) == B_OK) { if (volume.IsReadOnly() || !volume.IsPersistent()) continue; BDirectory trashDir; FSGetTrashDir(&trashDir, volume.Device()); trashDir.Rewind(); BEntry entry; if (trashDir.GetNextEntry(&entry) == B_OK) return true; } return false; }
void AutoMounter::_GetSettings(BMessage *message) { message->MakeEmpty(); bool all, bfs, restore; _FromMode(fNormalMode, all, bfs, restore); message->AddBool("initialMountAll", all); message->AddBool("initialMountAllBFS", bfs); message->AddBool("initialMountRestore", restore); _FromMode(fRemovableMode, all, bfs, restore); message->AddBool("autoMountAll", all); message->AddBool("autoMountAllBFS", bfs); message->AddBool("ejectWhenUnmounting", fEjectWhenUnmounting); // Save mounted volumes so we can optionally mount them on next // startup BVolumeRoster volumeRoster; BVolume volume; while (volumeRoster.GetNextVolume(&volume) == B_OK) { fs_info info; if (fs_stat_dev(volume.Device(), &info) == 0 && (info.flags & (B_FS_IS_REMOVABLE | B_FS_IS_PERSISTENT)) != 0) { message->AddString(info.device_name, info.volume_name); BString mountFlagsKey(info.device_name); mountFlagsKey << kMountFlagsKeyExtension; uint32 mountFlags = 0; if (volume.IsReadOnly()) mountFlags |= B_MOUNT_READ_ONLY; message->AddInt32(mountFlagsKey.String(), mountFlags); } } }
void TTracker::ReadyToRun() { gStatusWindow = new BStatusWindow(); InitMimeTypes(); InstallDefaultTemplates(); InstallIndices(); HideVarDir(); fTrashWatcher = new BTrashWatcher(); fTrashWatcher->Run(); fClipboardRefsWatcher = new BClipboardRefsWatcher(); fClipboardRefsWatcher->Run(); fAutoMounter = new AutoMounter(); fAutoMounter->Run(); fTaskLoop = new StandAloneTaskLoop(true); bool openDisksWindow = false; // open desktop window BContainerWindow *deskWindow = NULL; BVolume bootVol; BVolumeRoster().GetBootVolume(&bootVol); BDirectory deskDir; if (FSGetDeskDir(&deskDir, bootVol.Device()) == B_OK) { // create desktop BEntry entry; deskDir.GetEntry(&entry); Model *model = new Model(&entry); if (model->InitCheck() == B_OK) { AutoLock<WindowList> lock(&fWindowList); deskWindow = new BDeskWindow(&fWindowList); AutoLock<BWindow> windowLock(deskWindow); deskWindow->CreatePoseView(model); deskWindow->Init(); } else delete model; // open previously open windows attr_info attrInfo; if (!BootedInSafeMode() && deskDir.GetAttrInfo(kAttrOpenWindows, &attrInfo) == B_OK) { char *buffer = (char *)malloc((size_t)attrInfo.size); BMessage message; if (deskDir.ReadAttr(kAttrOpenWindows, B_MESSAGE_TYPE, 0, buffer, (size_t)attrInfo.size) == attrInfo.size && message.Unflatten(buffer) == B_OK) { node_ref nodeRef; deskDir.GetNodeRef(&nodeRef); int32 stateMessageCounter = 0; const char *path; for (int32 outer = 0;message.FindString("paths", outer, &path) == B_OK;outer++) { int8 flags = 0; for (int32 inner = 0;message.FindInt8(path, inner, &flags) == B_OK;inner++) { BEntry entry(path, true); if (entry.InitCheck() == B_OK) { Model *model = new Model(&entry); if (model->InitCheck() == B_OK && model->IsContainer()) { BMessage state; bool restoreStateFromMessage = false; if ((flags & kOpenWindowHasState) != 0 && message.FindMessage("window state", stateMessageCounter++, &state) == B_OK) restoreStateFromMessage = true; if (restoreStateFromMessage) OpenContainerWindow(model, 0, kOpen, kRestoreWorkspace | (flags & kOpenWindowMinimized ? kIsHidden : 0U), false, &state); else OpenContainerWindow(model, 0, kOpen, kRestoreWorkspace | (flags & kOpenWindowMinimized ? kIsHidden : 0U)); } else delete model; } } } if (message.HasBool("open_disks_window")) openDisksWindow = true; } free(buffer); } } // create model for root of everything if (deskWindow) { BEntry entry("/"); Model model(&entry); if (model.InitCheck() == B_OK) { if (TrackerSettings().ShowDisksIcon()) { // add the root icon to desktop window BMessage message; message.what = B_NODE_MONITOR; message.AddInt32("opcode", B_ENTRY_CREATED); message.AddInt32("device", model.NodeRef()->device); message.AddInt64("node", model.NodeRef()->node); message.AddInt64("directory", model.EntryRef()->directory); message.AddString("name", model.EntryRef()->name); deskWindow->PostMessage(&message, deskWindow->PoseView()); } if (openDisksWindow) OpenContainerWindow(new Model(model), 0, kOpen, kRestoreWorkspace); } } // kick off building the mime type list for find panels, etc. fMimeTypeList = new MimeTypeList(); if (!BootedInSafeMode()) // kick of transient query killer DeleteTransientQueriesTask::StartUpTransientQueryCleaner(); }
bool TTracker::QuitRequested() { // don't allow user quitting if (CurrentMessage() && CurrentMessage()->FindBool("shortcut")) return false; gStatusWindow->AttemptToQuit(); // try quitting the copy/move/empty trash threads BVolume bootVolume; DEBUG_ONLY(status_t err =) BVolumeRoster().GetBootVolume(&bootVolume); ASSERT(err == B_OK); BMessage message; AutoLock<WindowList> lock(&fWindowList); // save open windows in a message inside an attribute of the desktop int32 count = fWindowList.CountItems(); for (int32 i = 0; i < count; i++) { BContainerWindow *window = dynamic_cast<BContainerWindow *> (fWindowList.ItemAt(i)); if (window && window->TargetModel() && !window->PoseView()->IsDesktopWindow()) { if (window->TargetModel()->IsRoot()) message.AddBool("open_disks_window", true); else { BEntry entry; BPath path; const entry_ref *ref = window->TargetModel()->EntryRef(); if (entry.SetTo(ref) == B_OK && entry.GetPath(&path) == B_OK) { int8 flags = window->IsMinimized() ? kOpenWindowMinimized : kOpenWindowNoFlags; uint32 deviceFlags = GetVolumeFlags(window->TargetModel()); // save state for every window which is // a) already open on another workspace // b) on a volume not capable of writing attributes if (window != FindContainerWindow(ref) || (deviceFlags & (B_FS_HAS_ATTR | B_FS_IS_READONLY)) != B_FS_HAS_ATTR) { BMessage stateMessage; window->SaveState(stateMessage); window->SetSaveStateEnabled(false); // This is to prevent its state to be saved to the node when closed. message.AddMessage("window state", &stateMessage); flags |= kOpenWindowHasState; } const char *target; bool pathAlreadyExists = false; for (int32 index = 0;message.FindString("paths", index, &target) == B_OK;index++) { if (!strcmp(target,path.Path())) { pathAlreadyExists = true; break; } } if (!pathAlreadyExists) message.AddString("paths", path.Path()); message.AddInt8(path.Path(), flags); } } } } lock.Unlock(); // write windows to open on disk BDirectory deskDir; if (!BootedInSafeMode() && FSGetDeskDir(&deskDir, bootVolume.Device()) == B_OK) { // if message is empty, delete the corresponding attribute if (message.CountNames(B_ANY_TYPE)) { size_t size = (size_t)message.FlattenedSize(); char *buffer = new char[size]; message.Flatten(buffer, (ssize_t)size); deskDir.WriteAttr(kAttrOpenWindows, B_MESSAGE_TYPE, 0, buffer, size); delete [] buffer; } else deskDir.RemoveAttr(kAttrOpenWindows); } for (int32 count = 0; count == 50; count++) { // wait 5 seconds for the copiing/moving to quit if (gStatusWindow->AttemptToQuit()) break; snooze(100000); } return _inherited::QuitRequested(); }
status_t Settings::ReadSwapSettings() { void* settings = load_driver_settings(kVirtualMemorySettings); if (settings == NULL) return kErrorSettingsNotFound; CObjectDeleter<void, status_t> settingDeleter(settings, &unload_driver_settings); const char* enabled = get_driver_parameter(settings, "vm", NULL, NULL); const char* automatic = get_driver_parameter(settings, "swap_auto", NULL, NULL); const char* size = get_driver_parameter(settings, "swap_size", NULL, NULL); const char* volume = get_driver_parameter(settings, "swap_volume_name", NULL, NULL); const char* device = get_driver_parameter(settings, "swap_volume_device", NULL, NULL); const char* filesystem = get_driver_parameter(settings, "swap_volume_filesystem", NULL, NULL); const char* capacity = get_driver_parameter(settings, "swap_volume_capacity", NULL, NULL); if (enabled == NULL || automatic == NULL || size == NULL || device == NULL || volume == NULL || capacity == NULL || filesystem == NULL) return kErrorSettingsInvalid; off_t volCapacity = atoll(capacity); SetSwapEnabled(get_driver_boolean_parameter(settings, "vm", true, false)); SetSwapAutomatic(get_driver_boolean_parameter(settings, "swap_auto", true, false)); SetSwapSize(atoll(size)); int32 bestScore = -1; dev_t bestVol = -1; BVolume vol; fs_info volStat; BVolumeRoster roster; while (roster.GetNextVolume(&vol) == B_OK) { if (!vol.IsPersistent() || vol.IsReadOnly() || vol.IsRemovable() || vol.IsShared()) continue; if (fs_stat_dev(vol.Device(), &volStat) == 0) { int32 score = 0; if (strcmp(volume, volStat.volume_name) == 0) score += 4; if (strcmp(device, volStat.device_name) == 0) score += 3; if (volCapacity == volStat.total_blocks * volStat.block_size) score += 2; if (strcmp(filesystem, volStat.fsh_name) == 0) score += 1; if (score >= 4 && score > bestScore) { bestVol = vol.Device(); bestScore = score; } } } SetSwapVolume(bestVol); fInitialSettings = fCurrentSettings; if (bestVol < 0) return kErrorVolumeNotFound; return B_OK; }
void PrefsWindow::MessageReceived(BMessage *msg) { switch (msg->what) { case MSG_OK: { // "Start" button clicked read_volumes_prefs(); read_memory_prefs(); read_graphics_prefs(); SavePrefs(); send_quit_on_close = false; PostMessage(B_QUIT_REQUESTED); be_app->PostMessage(ok_message); break; } case MSG_CANCEL: // "Quit" button clicked send_quit_on_close = false; PostMessage(B_QUIT_REQUESTED); be_app->PostMessage(B_QUIT_REQUESTED); break; case B_ABOUT_REQUESTED: { // "About" menu item selected ShowAboutWindow(); break; } case MSG_ZAP_PRAM: // "Zap PRAM File" menu item selected ZapPRAM(); break; case MSG_VOLUME_INVOKED: { // Double-clicked on volume name, toggle read-only flag int selected = volume_list->CurrentSelection(); if (selected >= 0) { const char *str = PrefsFindString("disk", selected); BStringItem *item = (BStringItem *)volume_list->RemoveItem(selected); delete item; char newstr[256]; if (str[0] == '*') strcpy(newstr, str+1); else { strcpy(newstr, "*"); strcat(newstr, str); } PrefsReplaceString("disk", newstr, selected); volume_list->AddItem(new BStringItem(newstr), selected); volume_list->Select(selected); } break; } case MSG_ADD_VOLUME: add_volume_panel->Show(); break; case MSG_CREATE_VOLUME: create_volume_panel->Show(); break; case MSG_ADD_VOLUME_PANEL: { entry_ref ref; if (msg->FindRef("refs", &ref) == B_NO_ERROR) { BEntry entry(&ref, true); BPath path; entry.GetPath(&path); if (entry.IsFile()) { PrefsAddString("disk", path.Path()); volume_list->AddItem(new BStringItem(path.Path())); } else if (entry.IsDirectory()) { BVolume volume; if (path.Path()[0] == '/' && strchr(path.Path()+1, '/') == NULL && entry.GetVolume(&volume) == B_NO_ERROR) { int32 i = 0; dev_t d; fs_info info; while ((d = next_dev(&i)) >= 0) { fs_stat_dev(d, &info); if (volume.Device() == info.dev) { PrefsAddString("disk", info.device_name); volume_list->AddItem(new BStringItem(info.device_name)); } } } } } break; } case MSG_CREATE_VOLUME_PANEL: { entry_ref dir; if (msg->FindRef("directory", &dir) == B_NO_ERROR) { BEntry entry(&dir, true); BPath path; entry.GetPath(&path); path.Append(msg->FindString("name")); create_volume_panel->Window()->Lock(); BView *background = create_volume_panel->Window()->ChildAt(0); NumberControl *v = (NumberControl *)background->FindView("hardfile_size"); int size = v->Value(); char cmd[1024]; sprintf(cmd, "dd if=/dev/zero \"of=%s\" bs=1024k count=%d", path.Path(), size); int ret = system(cmd); if (ret == 0) { PrefsAddString("disk", path.Path()); volume_list->AddItem(new BStringItem(path.Path())); } else { sprintf(cmd, GetString(STR_CREATE_VOLUME_WARN), strerror(ret)); WarningAlert(cmd); } } break; } case MSG_REMOVE_VOLUME: { int selected = volume_list->CurrentSelection(); if (selected >= 0) { PrefsRemoveItem("disk", selected); BStringItem *item = (BStringItem *)volume_list->RemoveItem(selected); delete item; volume_list->Select(selected); } break; } case MSG_BOOT_ANY: PrefsReplaceInt32("bootdriver", 0); break; case MSG_BOOT_CDROM: PrefsReplaceInt32("bootdriver", CDROMRefNum); break; case MSG_NOCDROM: PrefsReplaceBool("nocdrom", nocdrom_checkbox->Value() == B_CONTROL_ON); break; case MSG_VIDEO_WINDOW: display_type = DISPLAY_WINDOW; hide_show_graphics_ctrls(); break; case MSG_VIDEO_SCREEN: display_type = DISPLAY_SCREEN; hide_show_graphics_ctrls(); break; case MSG_REF_5HZ: PrefsReplaceInt32("frameskip", 12); break; case MSG_REF_7_5HZ: PrefsReplaceInt32("frameskip", 8); break; case MSG_REF_10HZ: PrefsReplaceInt32("frameskip", 6); break; case MSG_REF_15HZ: PrefsReplaceInt32("frameskip", 4); break; case MSG_REF_30HZ: PrefsReplaceInt32("frameskip", 2); break; case MSG_NOSOUND: PrefsReplaceBool("nosound", nosound_checkbox->Value() == B_CONTROL_ON); break; case MSG_SER_A: { BMenuItem *source = NULL; msg->FindPointer("source", (void **)&source); if (source) PrefsReplaceString("seriala", source->Label()); break; } case MSG_SER_B: { BMenuItem *source = NULL; msg->FindPointer("source", (void **)&source); if (source) PrefsReplaceString("serialb", source->Label()); break; } case MSG_ETHER: if (ether_checkbox->Value() == B_CONTROL_ON) PrefsReplaceString("ether", "yes"); else PrefsRemoveItem("ether"); break; case MSG_UDPTUNNEL: PrefsReplaceBool("udptunnel", udptunnel_checkbox->Value() == B_CONTROL_ON); hide_show_serial_ctrls(); break; case MSG_RAMSIZE: PrefsReplaceInt32("ramsize", ramsize_slider->Value() * 1024 * 1024); break; case MSG_MODELID_5: PrefsReplaceInt32("modelid", 5); break; case MSG_MODELID_14: PrefsReplaceInt32("modelid", 14); break; case MSG_CPU_68020: PrefsReplaceInt32("cpu", 2); PrefsReplaceBool("fpu", false); break; case MSG_CPU_68020_FPU: PrefsReplaceInt32("cpu", 2); PrefsReplaceBool("fpu", true); break; case MSG_CPU_68030: PrefsReplaceInt32("cpu", 3); PrefsReplaceBool("fpu", false); break; case MSG_CPU_68030_FPU: PrefsReplaceInt32("cpu", 3); PrefsReplaceBool("fpu", true); break; case MSG_CPU_68040: PrefsReplaceInt32("cpu", 4); PrefsReplaceBool("fpu", true); break; default: { // Screen mode messages if ((msg->what & 0xffff0000) == MSG_SCREEN_MODE) { int m = msg->what & 0xffff; uint32 mask = scr_mode[m].mode_mask; for (int i=0; i<32; i++) if (mask & (1 << i)) scr_mode_bit = i; } else BWindow::MessageReceived(msg); } } }
int getmntent_haiku(int* cookie, struct mnttab* mp) { static BLocker mntent_locker; mntent_locker.Lock(); int ret = -1; BVolumeRoster roster; char buf[B_PATH_NAME_LENGTH]; int buflen = 0; BVolume volume; BDirectory rootDir; BEntry rootDirEntry; BPath rootDirPath; roster.Rewind(); for (int i = 0; i <= *cookie; i++) if (roster.GetNextVolume(&volume) != B_NO_ERROR) goto bail; // volume name volume.GetName(buf); buflen = strlen(buf); if (buflen == 0) { buflen = strlen(MNTENT_MP_UNKNOWN); strlcpy(buf, MNTENT_MP_UNKNOWN, buflen + 1); } mp->mnt_special = (char* )malloc(sizeof(char) * (buflen+1)); strlcpy(mp->mnt_special, buf, buflen+1); // mount point if (volume.GetRootDirectory(&rootDir) != B_OK || rootDir.GetEntry(&rootDirEntry) != B_OK || rootDirEntry.GetPath(&rootDirPath) != B_OK) goto bail; buflen = strlen(rootDirPath.Path()); mp->mnt_mountp = (char* )malloc(sizeof(char) * (buflen+1)); strlcpy(mp->mnt_mountp, rootDirPath.Path(), buflen + 1); // partition type. fs_info info; if (fs_stat_dev(volume.Device(), &info) != B_OK) goto bail; buflen = strlen(info.fsh_name); mp->mnt_fstype = (char* )malloc(sizeof(char) * (buflen+1)); strlcpy(mp->mnt_fstype, info.fsh_name, buflen+1); // fs options. set default options for all file systems for now. buflen = strlen(MNTENT_MP_DEFAULT_OPTS); mp->mnt_mntopts = (char* )malloc(sizeof(char) * (buflen+2+1)); // extra space for ro/rw strlcpy(mp->mnt_mntopts, MNTENT_MP_DEFAULT_OPTS, buflen + 2 + 1); strcat(mp->mnt_mntopts, volume.IsReadOnly() ? ",ro":",rw"); // mount time. no idea how i can get this. set it to 0 for now. buflen = 1; mp->mnt_time = (char* )malloc(sizeof(char) * (buflen+1)); strlcpy(mp->mnt_time, "0", buflen + 1); (*cookie)++; ret = 0; /* success! */ bail: mntent_locker.Unlock(); return ret; }
void PanelView::ReadDisks(void) //////////////////////////////////////////////////////////////////////// { char drivename[256]; char drivepath[256]; // SetMousePointer(CR_HOURGLASS); MAINWINDOW->SetMousePointer(GenesisWindow::CR_HOURGLASS); CustomListItem *item; item = new CustomListItem("..",m_Path.String(),FT_DISKBACK, 0); item->AddIcon(m_ParentIcon); m_CustomListView->AddItem(item); item->SetHeight(15.0f); // Collect available volumes... BVolumeRoster *vr = new BVolumeRoster(); if (vr) { BVolume v; while (vr->GetNextVolume(&v)==B_NO_ERROR) { if (v.GetName(drivename)==B_NO_ERROR) { if (strlen(drivename)>0) { BDirectory dir; BEntry entry; BPath path; v.GetRootDirectory(&dir); dir.GetEntry(&entry); entry.GetPath(&path); sprintf(drivepath,"%s",path.Path()); item = new CustomListItem(drivename,drivepath,FT_DISKITEM,v.FreeBytes(),v.Capacity(),v.Device()); m_CustomListView->AddItem(item); if (m_Setting_ShowIcons) { if (!item->GetIcon(&v)) item->AddIcon(m_UnknownIcon); item->SetHeight(15.0f); } } } } delete vr; } m_CustomListView->DoSortList(); m_CustomListView->Select(0,false); // SetMousePointer(CR_DEFAULT); MAINWINDOW->SetMousePointer(GenesisWindow::CR_DEFAULT); }
virtual bool Visit(BPartition* partition, int32 level) { BVolume volume; return partition->GetVolume(&volume) == B_OK && volume.Device() == fVolume; }
void TMailApp::ReadyToRun() { // Create needed indices for META:group, META:email, MAIL:draft, // INDEX_SIGNATURE, INDEX_STATUS on the boot volume BVolume volume; BVolumeRoster().GetBootVolume(&volume); fs_create_index(volume.Device(), "META:group", B_STRING_TYPE, 0); fs_create_index(volume.Device(), "META:email", B_STRING_TYPE, 0); fs_create_index(volume.Device(), "MAIL:draft", B_INT32_TYPE, 0); fs_create_index(volume.Device(), INDEX_SIGNATURE, B_STRING_TYPE, 0); fs_create_index(volume.Device(), INDEX_STATUS, B_STRING_TYPE, 0); fs_create_index(volume.Device(), B_MAIL_ATTR_FLAGS, B_INT32_TYPE, 0); // Start people queries fPeopleQueryList.Init("META:email=**"); // Load dictionaries BPath indexDir; BPath dictionaryDir; BPath userDictionaryDir; BPath userIndexDir; BPath dataPath; BPath indexPath; BDirectory directory; BEntry entry; // Locate dictionaries directory find_directory(B_SYSTEM_DATA_DIRECTORY, &indexDir, true); indexDir.Append("spell_check"); dictionaryDir = indexDir; //Locate user dictionary directory find_directory(B_USER_CONFIG_DIRECTORY, &userIndexDir, true); userIndexDir.Append("data/spell_check"); userDictionaryDir = userIndexDir; // Create directory if needed directory.CreateDirectory(userIndexDir.Path(), NULL); // Setup directory paths indexDir.Append(kIndexDirectory); dictionaryDir.Append(kDictDirectory); userIndexDir.Append(kIndexDirectory); userDictionaryDir.Append(kDictDirectory); // Create directories if needed directory.CreateDirectory(indexDir.Path(), NULL); directory.CreateDirectory(dictionaryDir.Path(), NULL); directory.CreateDirectory(userIndexDir.Path(), NULL); directory.CreateDirectory(userDictionaryDir.Path(), NULL); dataPath = dictionaryDir; dataPath.Append("words"); // Only Load if Words Dictionary if (BEntry(kWordsPath).Exists() || BEntry(dataPath.Path()).Exists()) { // If "/boot/optional/goodies/words" exists but there is no // system dictionary, copy words if (!BEntry(dataPath.Path()).Exists() && BEntry(kWordsPath).Exists()) { BFile words(kWordsPath, B_READ_ONLY); BFile copy(dataPath.Path(), B_WRITE_ONLY | B_CREATE_FILE); char buffer[4096]; ssize_t size; while ((size = words.Read( buffer, 4096)) > 0) copy.Write(buffer, size); BNodeInfo(©).SetType("text/plain"); } // Load dictionaries directory.SetTo(dictionaryDir.Path()); BString leafName; gUserDict = -1; while (gDictCount < MAX_DICTIONARIES && directory.GetNextEntry(&entry) != B_ENTRY_NOT_FOUND) { dataPath.SetTo(&entry); indexPath = indexDir; leafName.SetTo(dataPath.Leaf()); leafName.Append(kMetaphone); indexPath.Append(leafName.String()); gWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), true); indexPath = indexDir; leafName.SetTo(dataPath.Leaf()); leafName.Append(kExact); indexPath.Append(leafName.String()); gExactWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), false); gDictCount++; } // Create user dictionary if it does not exist dataPath = userDictionaryDir; dataPath.Append("user"); if (!BEntry(dataPath.Path()).Exists()) { BFile user(dataPath.Path(), B_WRITE_ONLY | B_CREATE_FILE); BNodeInfo(&user).SetType("text/plain"); } // Load user dictionary if (BEntry(userDictionaryDir.Path()).Exists()) { gUserDictFile = new BFile(dataPath.Path(), B_WRITE_ONLY | B_OPEN_AT_END); gUserDict = gDictCount; indexPath = userIndexDir; leafName.SetTo(dataPath.Leaf()); leafName.Append(kMetaphone); indexPath.Append(leafName.String()); gWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), true); indexPath = userIndexDir; leafName.SetTo(dataPath.Leaf()); leafName.Append(kExact); indexPath.Append(leafName.String()); gExactWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), false); gDictCount++; } } // Create a new window if starting up without any extra arguments. if (!fPrintHelpAndExit && !fWindowCount) { TMailWindow *window; window = NewWindow(); window->Show(); } }
status_t ExtractQueryVolumes(BNode *node, vollist *volumes) { int32 length = 0; char *attr = ReadAttribute(*node, kTrackerQueryVolume, &length); BVolumeRoster roster; if (attr == NULL) { roster.Rewind(); BVolume vol; while (roster.GetNextVolume(&vol) == B_NO_ERROR) { if ((vol.IsPersistent() == true) && (vol.KnowsQuery() == true)) { volumes->push_back(vol); }; }; } else { BMessage msg; msg.Unflatten(attr); // !*YOINK*!d from that project... with the funny little doggie as a logo... // OpenTracker, that's it! time_t created; off_t capacity; for (int32 index = 0; msg.FindInt32("creationDate", index, &created) == B_OK; index++) { if ((msg.FindInt32("creationDate", index, &created) != B_OK) || (msg.FindInt64("capacity", index, &capacity) != B_OK)) return B_ERROR; BVolume volume; BString deviceName = ""; BString volumeName = ""; BString fshName = ""; if (msg.FindString("deviceName", &deviceName) == B_OK && msg.FindString("volumeName", &volumeName) == B_OK && msg.FindString("fshName", &fshName) == B_OK) { // New style volume identifiers: We have a couple of characteristics, // and compute a score from them. The volume with the greatest score // (if over a certain threshold) is the one we're looking for. We // pick the first volume, in case there is more than one with the // same score. int foundScore = -1; roster.Rewind(); char name[B_FILE_NAME_LENGTH]; while (roster.GetNextVolume(&volume) == B_OK) { if (volume.IsPersistent() && volume.KnowsQuery()) { // get creation time and fs_info BDirectory root; volume.GetRootDirectory(&root); time_t cmpCreated; fs_info info; if (root.GetCreationTime(&cmpCreated) == B_OK && fs_stat_dev(volume.Device(), &info) == 0) { // compute the score int score = 0; // creation time if (created == cmpCreated) score += 5; // capacity if (capacity == volume.Capacity()) score += 4; // device name if (deviceName == info.device_name) score += 3; // volume name if (volumeName == info.volume_name) score += 2; // fsh name if (fshName == info.fsh_name) score += 1; // check score if (score >= 9 && score > foundScore) { volume.GetName(name); volumes->push_back(volume); } } } } } else { // Old style volume identifiers: We have only creation time and // capacity. Both must match. roster.Rewind(); while (roster.GetNextVolume(&volume) == B_OK) if (volume.IsPersistent() && volume.KnowsQuery()) { BDirectory root; volume.GetRootDirectory(&root); time_t cmpCreated; root.GetCreationTime(&cmpCreated); if (created == cmpCreated && capacity == volume.Capacity()) { volumes->push_back(volume); } } } }; }; return B_OK; };