status_t QueryEntryListCollection::FetchOneQuery(const BQuery* copyThis, BHandler* target, BObjectList<BQuery>* list, BVolume* volume) { BQuery* query = new (nothrow) BQuery; if (query == NULL) return B_NO_MEMORY; // have to fake a copy constructor here because BQuery doesn't have // a copy constructor BString buffer; const_cast<BQuery*>(copyThis)->GetPredicate(&buffer); query->SetPredicate(buffer.String()); query->SetTarget(BMessenger(target)); query->SetVolume(volume); status_t result = query->Fetch(); if (result != B_OK) { PRINT(("fetch error %s\n", strerror(result))); delete query; return result; } list->AddItem(query); return B_OK; }
void TReplicantTray::RunAddOnQuery(BVolume* volume, const char* predicate) { // Since the new BFS supports querying for attributes without // an index, we only run the query if the index exists (for // newly mounted devices only - the Deskbar will automatically // create an index for every device mounted at startup). index_info info; if (!volume->KnowsQuery() || fs_stat_index(volume->Device(), kStatusPredicate, &info) != 0) return; // run a new query on a specific volume and make it live BQuery query; query.SetVolume(volume); query.SetPredicate(predicate); query.Fetch(); int32 id; BEntry entry; while (query.GetNextEntry(&entry) == B_OK) { // scan any entries returned // attempt to load them as add-ons // collisions are handled in LoadAddOn LoadAddOn(&entry, &id); } }
bool GeneralView::_CanFindServer(entry_ref* ref) { // Try searching with be_roster if (be_roster->FindApp(kNotificationServerSignature, ref) == B_OK) return true; // Try with a query and take the first result BVolumeRoster vroster; BVolume volume; char volName[B_FILE_NAME_LENGTH]; vroster.Rewind(); while (vroster.GetNextVolume(&volume) == B_OK) { if ((volume.InitCheck() != B_OK) || !volume.KnowsQuery()) continue; volume.GetName(volName); BQuery *query = new BQuery(); query->SetPredicate("(BEOS:APP_SIG==\""kNotificationServerSignature"\")"); query->SetVolume(&volume); query->Fetch(); if (query->GetNextRef(ref) == B_OK) return true; } return false; }
void LiveQuery::MessageReceived(BMessage* message) { switch (message->what) { case kMsgAddQuery: { int32 device; const char* predicate; if (message->FindInt32("volume", &device) != B_OK || message->FindString("predicate", &predicate) != B_OK) break; BVolume volume(device); BQuery* query = new BQuery; // Set up the volume and predicate for the query. query->SetVolume(&volume); query->SetPredicate(predicate); query->SetTarget(this); fQueries.AddItem(query); _PerformQuery(*query); break; } case B_QUERY_UPDATE: { int32 what; message->FindInt32("opcode", &what); int32 device; int64 directory; int64 node; const char* name; message->FindInt32("device", &device); message->FindInt64("directory", &directory); message->FindInt64("node", &node); message->FindString("name", &name); switch (what) { case B_ENTRY_CREATED: { printf("CREATED %s\n", name); break; } case B_ENTRY_REMOVED: printf("REMOVED %s\n", name); break; } break; } default: BApplication::MessageReceived(message); break; } }
void THeaderView::InitEmailCompletion() { // get boot volume BVolume volume; BVolumeRoster().GetBootVolume(&volume); BQuery query; query.SetVolume(&volume); query.SetPredicate("META:email=**"); // Due to R5 BFS bugs, you need two stars, META:email=** for the query. // META:email="*" will just return one entry and stop, same with // META:email=* and a few other variations. Grumble. query.Fetch(); entry_ref ref; while (query.GetNextRef (&ref) == B_OK) { BNode file; if (file.SetTo(&ref) == B_OK) { // Add the e-mail address as an auto-complete string. BString email; if (file.ReadAttrString("META:email", &email) >= B_OK) fEmailList.AddChoice(email.String()); // Also add the quoted full name as an auto-complete string. Can't // do unquoted since auto-complete isn't that smart, so the user // will have to type a quote mark if he wants to select someone by // name. BString fullName; if (file.ReadAttrString("META:name", &fullName) >= B_OK) { if (email.FindFirst('<') < 0) { email.ReplaceAll('>', '_'); email.Prepend("<"); email.Append(">"); } fullName.ReplaceAll('\"', '_'); fullName.Prepend("\""); fullName << "\" " << email; fEmailList.AddChoice(fullName.String()); } // support for 3rd-party People apps. Looks like a job for // multiple keyword (so you can have several e-mail addresses in // one attribute, perhaps comma separated) indices! Which aren't // yet in BFS. for (int16 i = 2; i < 6; i++) { char attr[16]; sprintf(attr, "META:email%d", i); if (file.ReadAttrString(attr, &email) >= B_OK) fEmailList.AddChoice(email.String()); } } } }
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 QueryView::GetInitialEntries() { fEntryCount = 0; entry_ref ref; // slaad BNode n(&ref); vollist vols; ExtractQueryVolumes(&n, &vols); vollist::iterator vIt; for (vIt = vols.begin(); vIt != vols.end(); vIt++) { BQuery *query = new BQuery(); query->SetVolume(&(*vIt)); query->SetPredicate(fPredicate.String()); query->SetTarget(this); query->Fetch(); while( query->GetNextRef(&ref) == B_OK ) { // eiman BEntry entry(&ref); node_ref node; entry.GetNodeRef(&node); BMessage msg; msg.AddInt32("opcode",B_ENTRY_CREATED); msg.AddString("name",ref.name); msg.AddInt64("directory",ref.directory); msg.AddInt32("device",ref.device); msg.AddInt64("node",node.node); if ( !ShouldIgnore(&msg) ) { fEntryCount++; } } fQueries.push_back(query); }; #ifdef DEBUG BeDC dc("QueryWatcher"); BString str; str<<Name()<<" initial count: "<<fEntryCount; dc.SendMessage(str.String()); #endif UpdateDisplay(); }
status_t TeamWindow::_RetrieveMatchingSourceEntries(const BString& path, BStringList* _entries) { BPath filePath(path); status_t error = filePath.InitCheck(); if (error != B_OK) return error; _entries->MakeEmpty(); BQuery query; BString predicate; query.PushAttr("name"); query.PushString(filePath.Leaf()); query.PushOp(B_EQ); error = query.GetPredicate(&predicate); if (error != B_OK) return error; BVolumeRoster roster; BVolume volume; while (roster.GetNextVolume(&volume) == B_OK) { if (!volume.KnowsQuery()) continue; if (query.SetVolume(&volume) != B_OK) continue; error = query.SetPredicate(predicate.String()); if (error != B_OK) continue; if (query.Fetch() != B_OK) continue; entry_ref ref; while (query.GetNextRef(&ref) == B_OK) { filePath.SetTo(&ref); _entries->Add(filePath.Path()); } query.Clear(); } return B_OK; }
BPopUpMenu* TPrefsWindow::_BuildSignatureMenu(char* sig) { char name[B_FILE_NAME_LENGTH]; BEntry entry; BFile file; BMenuItem* item; BMessage* msg; BQuery query; BVolume vol; BVolumeRoster volume; BPopUpMenu* menu = new BPopUpMenu(""); msg = new BMessage(P_SIG); msg->AddString("signature", B_TRANSLATE("None")); menu->AddItem(item = new BMenuItem(B_TRANSLATE("None"), msg)); if (!strcmp(sig, B_TRANSLATE("None"))) item->SetMarked(true); msg = new BMessage(P_SIG); msg->AddString("signature", B_TRANSLATE("Random")); menu->AddItem(item = new BMenuItem(B_TRANSLATE("Random"), msg)); if (!strcmp(sig, B_TRANSLATE("Random"))) item->SetMarked(true); menu->AddSeparatorItem(); volume.GetBootVolume(&vol); query.SetVolume(&vol); query.SetPredicate("_signature = *"); query.Fetch(); while (query.GetNextEntry(&entry) == B_NO_ERROR) { file.SetTo(&entry, O_RDONLY); if (file.InitCheck() == B_NO_ERROR) { msg = new BMessage(P_SIG); file.ReadAttr("_signature", B_STRING_TYPE, 0, name, sizeof(name)); msg->AddString("signature", name); menu->AddItem(item = new BMenuItem(name, msg)); if (!strcmp(sig, name)) item->SetMarked(true); } } return menu; }
void Feeder::AddQuery(BVolume *volume) { fVolumeList.AddItem((void*)volume) ; BQuery *query = new BQuery ; query->SetVolume(volume) ; // query->SetPredicate("name = *.txt") ; query->SetPredicate("last_modified > %now%") ; query->SetTarget(this) ; if (query->Fetch() == B_OK) { RetrieveStaticRefs(query) ; fQueryList.AddItem((void *)query) ; } else delete query ; }
int main(int argc, char** argv) { if (argc < 2) { fprintf(stderr, "usage: %s <message-code>\n", __progname); return -1; } int32 number = atol(argv[1]); BQuery query; query.SetPredicate("name=ServerProtocol.h"); // search on current volume only dev_t device = dev_for_path("."); BVolume volume(device); query.SetVolume(&volume); query.Fetch(); status_t status; BEntry entry; while ((status = query.GetNextEntry(&entry)) == B_OK) { BPath path(&entry); puts(path.Path()); if (strstr(path.Path(), "headers/private/app/ServerProtocol.h") != NULL) { print_code(path, number); break; } } if (status != B_OK) { fprintf(stderr, "%s: could not find ServerProtocol.h", __progname); return -1; } return 0; }
void QueryLooper::MessageReceived(BMessage *msg) { switch (msg->what) { case B_QUERY_UPDATE: { int32 opcode = 0; entry_ref affected; if (msg->FindInt32("opcode", &opcode) != B_OK) return; switch (opcode) { case B_ENTRY_CREATED: { result r; const char *name; msg->FindInt32("device", &r.ref.device); msg->FindInt64("directory", &r.ref.directory); msg->FindString("name", &name); r.ref.set_name(name); msg->FindInt32("device", &r.nref.device); msg->FindInt64("node", &r.nref.node); fResults[r.ref] = r; affected = r.ref; } break; case B_ENTRY_REMOVED: { node_ref nref; result_t::iterator rIt; msg->FindInt32("device", &nref.device); msg->FindInt64("node", &nref.node); for (rIt = fResults.begin(); rIt != fResults.end(); rIt++) { result r = rIt->second; if (nref == r.nref) { fResults.erase(r.ref); affected = r.ref; break; }; }; } break; }; if ((fNotify.IsValid()) && (fMsg != NULL)) { BMessage notify(*fMsg); notify.AddString("qlName", fName); notify.AddRef("affected_ref", &affected); if (opcode == B_ENTRY_CREATED) { notify.AddInt32("query_what", Notifications::EntryAdded); } else { notify.AddInt32("query_what", Notifications::EntryRemoved); }; #if B_BEOS_VERSION > B_BEOS_VERSION_5 fNotify.SendMessage(notify); #else fNotify.SendMessage(¬ify); #endif }; } break; case msgInitialFetch: { volume_t::iterator vIt; for (vIt = fVolumes.begin(); vIt != fVolumes.end(); vIt++) { BVolume vol = (*vIt); BQuery *query = new BQuery(); query->SetPredicate(fPredicate.String()); query->SetTarget(this); query->SetVolume(&vol); query->Fetch(); entry_ref ref; while (query->GetNextRef(&ref) == B_OK) { BNode node(&ref); result r; r.ref = ref; node.GetNodeRef(&r.nref); fResults[ref] = r; }; fQueries.push_back(query); }; if ((fNotify.IsValid()) && (fMsg != NULL)) { BMessage notify(*fMsg); notify.AddString("qlName", fName); notify.AddInt32("query_what", Notifications::InitialFetch); #if B_BEOS_VERSION > B_BEOS_VERSION_5 fNotify.SendMessage(notify); #else fNotify.SendMessage(¬ify); #endif }; } break; default: { BLooper::MessageReceived(msg); }; }; };
int main(int argc, char* argv[]) { team_info teamInfo; int32 cookie = 0; while (get_next_team_info(&cookie, &teamInfo) == B_OK) { if (!strncmp(teamInfo.args, "/boot/beos/", 11) || !strncmp(teamInfo.args, "/boot/system/", 13)) { // this is a system component and not worth to investigate continue; } thread_info threadInfo; int32 threadCookie = 0; while (get_next_thread_info(teamInfo.team, &threadCookie, &threadInfo) == B_OK) { // search for the roster thread if (!strcmp(threadInfo.name, "_roster_thread_")) { port_id port = find_port("haiku-test:roster"); port_info portInfo; if (get_port_info(port, &portInfo) == B_OK && portInfo.team == teamInfo.team) { puts("The Haiku Registrar is already running."); return 0; } } } } // the Haiku registrar doesn't seem to run yet, change this BPath currentPath("."); BQuery query; query.SetPredicate("name==test_registrar"); // search on current volume only dev_t device = dev_for_path("."); BVolume volume(device); query.SetVolume(&volume); query.Fetch(); entry_ref ref; while (query.GetNextRef(&ref) == B_OK) { BPath path(&ref); if (path.InitCheck() != B_OK) continue; const char* registrarPath = path.Path(); const char* generatedPath = strstr(registrarPath, "generated"); if (generatedPath == NULL) continue; if (!strncmp(currentPath.Path(), registrarPath, generatedPath - registrarPath)) { // gotcha! if (launch_registrar(registrarPath) == B_OK) return 0; } } // As a fallback (maybe the volume does not support queries for example) // try to find the test_registrar in the current folder... BString registrarPath(argv[0]); registrarPath.RemoveLast(__progname); registrarPath.Append("test_registrar"); if (launch_registrar(registrarPath.String()) == B_OK) return 0; fprintf(stderr, "%s: Could not find the Haiku Registrar.\n" " (This tool only works when used in the Haiku tree, but maybe\n" " the registrar just needs to be built.)\n", __progname); return -1; }
/*********************************************************** * Fetching ***********************************************************/ void HQueryItem::Fetching() { bool some_success = false; BVolume volume; BVolumeRoster roster; while (fQueries.CountItems()) { delete static_cast<BQuery *>(fQueries.RemoveItem((int32)0)); } uint32 count_items = 0; while (roster.GetNextVolume(&volume) == B_OK) { BQuery *query = new BQuery; fQueries.AddItem((void*)query); query->Clear(); query->SetTarget(*fMessenger); query->SetVolume(&volume); query->SetPredicate(fPredicate.String()); char type[B_MIME_TYPE_LENGTH+1]; BNode node; HMailItem *item(NULL); if(query->Fetch() == B_OK) { some_success = true; entry_ref ref; char buf[4096]; dirent *dent; int32 count; int32 offset; while (((count = query->GetNextDirents((dirent *)buf, 4096)) > 0) && (!fCancel)) { offset = 0; /* Now we step through the dirents. */ while (count-- > 0) { dent = (dirent *)buf + offset; offset += dent->d_reclen; /* Skip . and .. directory */ if(::strcmp(dent->d_name,".") == 0 || ::strcmp(dent->d_name,"..")== 0) continue; ref.device = dent->d_pdev; ref.directory = dent->d_pino; ref.set_name(dent->d_name); if(node.SetTo(&ref) != B_OK) continue; node.ReadAttr("BEOS:TYPE",'MIMS',0,type,B_MIME_TYPE_LENGTH); if(::strcmp(type,B_MAIL_TYPE) == 0) { fMailList.AddItem(item = new HMailItem(ref)); if(item && !item->IsRead() ) count_items++; } } } }DEBUG_ONLY( else{ PRINT(("Query fetching was failed\n")); } ); }
QueryEntryListCollection::QueryEntryListCollection(Model* model, BHandler* target, PoseList* oldPoseList) : fQueryListRep(new QueryListRep(new BObjectList<BQuery>(5, true))) { Rewind(); attr_info info; BQuery query; if (!model->Node()) { fStatus = B_ERROR; return; } // read the actual query string fStatus = model->Node()->GetAttrInfo(kAttrQueryString, &info); if (fStatus != B_OK) return; BString buffer; if (model->Node()->ReadAttr(kAttrQueryString, B_STRING_TYPE, 0, buffer.LockBuffer((int32)info.size), (size_t)info.size) != info.size) { fStatus = B_ERROR; return; } buffer.UnlockBuffer(); // read the extra options MoreOptionsStruct saveMoreOptions; if (ReadAttr(model->Node(), kAttrQueryMoreOptions, kAttrQueryMoreOptionsForeign, B_RAW_TYPE, 0, &saveMoreOptions, sizeof(MoreOptionsStruct), &MoreOptionsStruct::EndianSwap) != kReadAttrFailed) { fQueryListRep->fShowResultsFromTrash = saveMoreOptions.searchTrash; } fStatus = query.SetPredicate(buffer.String()); fQueryListRep->fOldPoseList = oldPoseList; fQueryListRep->fDynamicDateQuery = false; fQueryListRep->fRefreshEveryHour = false; fQueryListRep->fRefreshEveryMinute = false; if (model->Node()->ReadAttr(kAttrDynamicDateQuery, B_BOOL_TYPE, 0, &fQueryListRep->fDynamicDateQuery, sizeof(bool)) != sizeof(bool)) { fQueryListRep->fDynamicDateQuery = false; } if (fQueryListRep->fDynamicDateQuery) { // only refresh every minute on debug builds fQueryListRep->fRefreshEveryMinute = buffer.IFindFirst("second") != -1 || buffer.IFindFirst("minute") != -1; fQueryListRep->fRefreshEveryHour = fQueryListRep->fRefreshEveryMinute || buffer.IFindFirst("hour") != -1; #if !DEBUG // don't refresh every minute unless we are running debug build fQueryListRep->fRefreshEveryMinute = false; #endif } if (fStatus != B_OK) return; bool searchAllVolumes = true; status_t result = B_OK; // get volumes to perform query on if (model->Node()->GetAttrInfo(kAttrQueryVolume, &info) == B_OK) { char* buffer = NULL; if ((buffer = (char*)malloc((size_t)info.size)) != NULL && model->Node()->ReadAttr(kAttrQueryVolume, B_MESSAGE_TYPE, 0, buffer, (size_t)info.size) == info.size) { BMessage message; if (message.Unflatten(buffer) == B_OK) { for (int32 index = 0; ;index++) { ASSERT(index < 100); BVolume volume; // match a volume with the info embedded in // the message result = MatchArchivedVolume(&volume, &message, index); if (result == B_OK) { // start the query on this volume result = FetchOneQuery(&query, target, fQueryListRep->fQueryList, &volume); if (result != B_OK) continue; searchAllVolumes = false; } else if (result != B_DEV_BAD_DRIVE_NUM) { // if B_DEV_BAD_DRIVE_NUM, the volume just isn't // mounted this time around, keep looking for more // if other error, bail break; } } } } free(buffer); } if (searchAllVolumes) { // no specific volumes embedded in query, search everything BVolumeRoster roster; BVolume volume; roster.Rewind(); while (roster.GetNextVolume(&volume) == B_OK) if (volume.IsPersistent() && volume.KnowsQuery()) { result = FetchOneQuery(&query, target, fQueryListRep->fQueryList, &volume); if (result != B_OK) continue; } } fStatus = B_OK; return; }
/*********************************************************** * InitGUI ***********************************************************/ void HAddressView::InitGUI() { float divider = StringWidth(_("Subject:")) + 20; divider = max_c(divider , StringWidth(_("From:"))+20); divider = max_c(divider , StringWidth(_("To:"))+20); divider = max_c(divider , StringWidth(_("Bcc:"))+20); BRect rect = Bounds(); rect.top += 5; rect.left += 20 + divider; rect.right = Bounds().right - 5; rect.bottom = rect.top + 25; BTextControl *ctrl; ResourceUtils rutils; const char* name[] = {"to","subject","from","cc","bcc"}; for(int32 i = 0;i < 5;i++) { ctrl = new BTextControl(BRect(rect.left,rect.top ,(i == 1)?rect.right+divider:rect.right ,rect.bottom) ,name[i],"","",NULL ,B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP,B_WILL_DRAW|B_NAVIGABLE); if(i == 1) { ctrl->SetLabel(_("Subject:")); ctrl->SetDivider(divider); ctrl->MoveBy(-divider,0); }else{ ctrl->SetDivider(0); } BMessage *msg = new BMessage(M_MODIFIED); msg->AddPointer("pointer",ctrl); ctrl->SetModificationMessage(msg); ctrl->SetEnabled(!fReadOnly); AddChild(ctrl); rect.OffsetBy(0,25); switch(i) { case 0: fTo = ctrl; break; case 1: fSubject = ctrl; break; case 2: fFrom = ctrl; fFrom->SetEnabled(false); fFrom->SetFlags(fFrom->Flags() & ~B_NAVIGABLE); break; case 3: fCc = ctrl; break; case 4: fBcc = ctrl; break; } } // BRect menuRect= Bounds(); menuRect.top += 5; menuRect.left += 22; menuRect.bottom = menuRect.top + 25; menuRect.right = menuRect.left + 16; BMenu *toMenu = new BMenu(_("To:")); BMenu *ccMenu = new BMenu(_("Cc:")); BMenu *bccMenu = new BMenu(_("Bcc:")); BQuery query; BVolume volume; BVolumeRoster().GetBootVolume(&volume); query.SetVolume(&volume); query.SetPredicate("((META:email=*)&&(BEOS:TYPE=application/x-person))"); if(!fReadOnly && query.Fetch() == B_OK) { BString addr[4],name,group,nick; entry_ref ref; BList peopleList; while(query.GetNextRef(&ref) == B_OK) { BNode node(&ref); if(node.InitCheck() != B_OK) continue; ReadNodeAttrString(&node,"META:name",&name); ReadNodeAttrString(&node,"META:email",&addr[0]); ReadNodeAttrString(&node,"META:email2",&addr[1]); ReadNodeAttrString(&node,"META:email3",&addr[2]); ReadNodeAttrString(&node,"META:email4",&addr[3]); ReadNodeAttrString(&node,"META:group",&group); ReadNodeAttrString(&node,"META:nickname",&nick); for(int32 i = 0;i < 4;i++) { if(addr[i].Length() > 0) { if(nick.Length() > 0) { nick += " <"; nick += addr[i]; nick += ">"; fAddrList.AddItem(strdup(nick.String())); } fAddrList.AddItem(strdup(addr[i].String())); BString title = name; title << " <" << addr[i] << ">"; AddPersonToList(peopleList,title.String(),group.String()); } } } // Sort people data peopleList.SortItems(HAddressView::SortPeople); // Build menus BTextControl *control[3] = {fTo,fCc,fBcc}; BMenu *menus[3] = {toMenu,ccMenu,bccMenu}; int32 count = peopleList.CountItems(); PersonData *data; bool needSeparator = false; bool hasSeparator = false; for(int32 k = 0;k < 3;k++) { for(int32 i = 0;i < count;i++) { BMessage *msg = new BMessage(M_ADDR_MSG); msg->AddPointer("pointer",control[k]); data = (PersonData*)peopleList.ItemAt(i); msg->AddString("email",data->email); if(needSeparator && !hasSeparator && strlen(data->group) == 0) { menus[k]->AddSeparatorItem(); hasSeparator = true; }else needSeparator = true; AddPerson(menus[k],data->email,data->group,msg,0,0); } hasSeparator = false; needSeparator = false; } // free all data while(count > 0) { data = (PersonData*)peopleList.RemoveItem(--count); free(data->email); free(data->group); delete data; } } BMenuField *field = new BMenuField(menuRect,"ToMenu","",toMenu, B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW); field->SetDivider(0); field->SetEnabled(!fReadOnly); AddChild(field); rect = menuRect; rect.OffsetBy(0,28); rect.left = Bounds().left + 5; rect.right = rect.left + 16; rect.top += 26; rect.bottom = rect.top + 16; ArrowButton *arrow = new ArrowButton(rect,"addr_arrow" ,new BMessage(M_EXPAND_ADDRESS)); AddChild(arrow); //==================== From menu BMenu *fromMenu = new BMenu(_("From:")); BPath path; ::find_directory(B_USER_SETTINGS_DIRECTORY,&path); path.Append(APP_NAME); path.Append("Accounts"); BDirectory dir(path.Path()); BEntry entry; status_t err = B_OK; int32 account_count = 0; while(err == B_OK) { if((err = dir.GetNextEntry(&entry)) == B_OK && !entry.IsDirectory()) { char name[B_FILE_NAME_LENGTH+1]; entry.GetName(name); BMessage *msg = new BMessage(M_ACCOUNT_CHANGE); msg->AddString("name",name); BMenuItem *item = new BMenuItem(name,msg); fromMenu->AddItem(item); item->SetTarget(this,Window()); account_count++; } } if(account_count != 0) { int32 smtp_account; ((HApp*)be_app)->Prefs()->GetData("smtp_account",&smtp_account); BMenuItem *item(NULL); if(account_count > smtp_account) item = fromMenu->ItemAt(smtp_account); if(!item) item = fromMenu->ItemAt(0); if(item) { ChangeAccount(item->Label()); item->SetMarked(true); } }else{ (new BAlert("",_("Could not find mail accounts"),_("OK"),NULL,NULL,B_WIDTH_AS_USUAL,B_INFO_ALERT))->Go(); Window()->PostMessage(B_QUIT_REQUESTED); } fromMenu->SetRadioMode(true); menuRect.OffsetBy(0,25*2); field = new BMenuField(menuRect,"FromMenu","",fromMenu, B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW); field->SetDivider(0); AddChild(field); //=================== CC menu menuRect.OffsetBy(0,25); field = new BMenuField(menuRect,"CcMenu","",ccMenu, B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW); field->SetDivider(0); field->SetEnabled(!fReadOnly); AddChild(field); //=================== BCC menu menuRect.OffsetBy(0,25); field = new BMenuField(menuRect,"BccMenu","",bccMenu, B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW); field->SetDivider(0); field->SetEnabled(!fReadOnly); AddChild(field); }
void PersonView::BuildGroupMenu() { if (fGroups == NULL) return; BMenuItem* item; while ((item = fGroups->ItemAt(0)) != NULL) { fGroups->RemoveItem(item); delete item; } int32 count = 0; BVolumeRoster volumeRoster; BVolume volume; while (volumeRoster.GetNextVolume(&volume) == B_OK) { BQuery query; query.SetVolume(&volume); char buffer[256]; snprintf(buffer, sizeof(buffer), "%s=*", fCategoryAttribute.String()); query.SetPredicate(buffer); query.Fetch(); BEntry entry; while (query.GetNextEntry(&entry) == B_OK) { BFile file(&entry, B_READ_ONLY); attr_info info; if (file.InitCheck() == B_OK && file.GetAttrInfo(fCategoryAttribute, &info) == B_OK && info.size > 1) { if (info.size > (off_t)sizeof(buffer)) info.size = sizeof(buffer); if (file.ReadAttr(fCategoryAttribute.String(), B_STRING_TYPE, 0, buffer, info.size) < 0) { continue; } const char *text = buffer; while (true) { char* offset = strstr(text, ","); if (offset != NULL) offset[0] = '\0'; if (!fGroups->FindItem(text)) { int32 index = 0; while ((item = fGroups->ItemAt(index)) != NULL) { if (strcmp(text, item->Label()) < 0) break; index++; } BMessage* message = new BMessage(M_GROUP_MENU); message->AddString("group", text); fGroups->AddItem(new BMenuItem(text, message), index); count++; } if (offset) { text = offset + 1; while (*text == ' ') text++; } else break; } } } } if (count == 0) { fGroups->AddItem(item = new BMenuItem( B_TRANSLATE_CONTEXT("none", "Groups list"), new BMessage(M_GROUP_MENU))); item->SetEnabled(false); } fGroups->SetTargetForItems(this); }
int main() { team_info teamInfo; int32 cookie = 0; while (get_next_team_info(&cookie, &teamInfo) == B_OK) { if (!strncmp(teamInfo.args, "/boot/beos/", 11)) { // this is a system component and not worth to investigate continue; } thread_info threadInfo; int32 threadCookie = 0; while (get_next_thread_info(teamInfo.team, &threadCookie, &threadInfo) == B_OK) { // search for the roster thread if (!strcmp(threadInfo.name, "_roster_thread_")) { port_id port = find_port("antares-test:roster"); port_info portInfo; if (get_port_info(port, &portInfo) == B_OK && portInfo.team == teamInfo.team) { puts("The Antares Registrar is already running."); return 0; } } } } // the Antares registrar doesn't seem to run yet, change this BPath currentPath("."); BQuery query; query.SetPredicate("name==test_registrar"); // search on current volume only dev_t device = dev_for_path("."); BVolume volume(device); query.SetVolume(&volume); query.Fetch(); entry_ref ref; while (query.GetNextRef(&ref) == B_OK) { BPath path(&ref); if (path.InitCheck() != B_OK) continue; const char* registrarPath = path.Path(); const char* generatedPath = strstr(registrarPath, "generated"); if (generatedPath == NULL) continue; if (!strncmp(currentPath.Path(), registrarPath, generatedPath - registrarPath)) { // gotcha! const char* args[] = { registrarPath, NULL }; thread_id thread = load_image(1, args, (const char**)environ); if (thread < B_OK) { fprintf(stderr, "%s: Could not start the registrar: %s\n", __progname, strerror(thread)); return -1; } resume_thread(thread); return 0; } } fprintf(stderr, "%s: Could not find the Antares Registrar.\n" " (This tool only works when used in the Antares tree, but maybe\n" " the registrar just needs to be built.)\n", __progname); return -1; }
bool duplicates_exist (const char * signature) { BVolumeRoster roster; BVolume volume; BQuery query; BString query_string = "BEOS:APP_SIG="; BEntry entry; mode_t permissions; uid_t owner; gid_t group; int32 query_hits = 0; query_string += signature; while (roster.GetNextVolume(& volume) == B_OK) { if (volume.KnowsQuery()) { PRINT(("volume.KnowsQuery()\n")); char volname [B_FILE_NAME_LENGTH]; volume.GetName(volname); PRINT(("volume: %s\n", volname)); query.Clear(); if (query.SetVolume(& volume) == B_OK) { PRINT(("query.SetVolume(& volume) == B_OK\n")); if (query.SetPredicate(query_string.String()) == B_OK) { PRINT(("query.SetPredicate(%s) == B_OK\n", query_string.String())); if (query.Fetch() == B_OK) { PRINT(("query.Fetch() == B_OK\n")); while (query.GetNextEntry(& entry) == B_OK) { PRINT(("query.GetNextEntry(& entry) == B_OK\n")); entry.GetPermissions(& permissions); entry.GetOwner(& owner); entry.GetGroup(& group); BPath path (& entry); // if (access(path.Path(), X_OK)) if (((owner == getuid()) && (permissions & S_IXUSR)) || ((group == getgid()) && (permissions & S_IXGRP)) || (permissions & S_IXOTH)) { PRINT(("path is executable: %s\n", path.Path())); query_hits++; } else { PRINT(("path is NOT executable: %s\n", path.Path())); } } } } } } fflush(stdout); } if (query_hits > 1) return true; else return false; }
void THeaderView::InitGroupCompletion() { // get boot volume BVolume volume; BVolumeRoster().GetBootVolume(&volume); // Build a list of all unique groups and the addresses they expand to. BQuery query; query.SetVolume(&volume); query.SetPredicate("META:group=**"); query.Fetch(); map<BString *, BString *, CompareBStrings> groupMap; entry_ref ref; BNode file; while (query.GetNextRef(&ref) == B_OK) { if (file.SetTo(&ref) != B_OK) continue; BString groups; if (file.ReadAttrString("META:group", &groups) < B_OK || groups.Length() == 0) continue; BString address; file.ReadAttrString("META:email", &address); // avoid adding an empty address if (address.Length() == 0) continue; char *group = groups.LockBuffer(groups.Length()); char *next = strchr(group, ','); for (;;) { if (next) *next = 0; while (*group && *group == ' ') group++; BString *groupString = new BString(group); BString *addressListString = NULL; // nobody is in this group yet, start it off if (groupMap[groupString] == NULL) { addressListString = new BString(*groupString); addressListString->Append(" "); groupMap[groupString] = addressListString; } else { addressListString = groupMap[groupString]; addressListString->Append(", "); delete groupString; } // Append the user's address to the end of the string with the // comma separated list of addresses. If not present, add the // < and > brackets around the address. if (address.FindFirst ('<') < 0) { address.ReplaceAll ('>', '_'); address.Prepend ("<"); address.Append(">"); } addressListString->Append(address); if (!next) break; group = next + 1; next = strchr(group, ','); } } map<BString *, BString *, CompareBStrings>::iterator iter; for (iter = groupMap.begin(); iter != groupMap.end();) { BString *group = iter->first; BString *addr = iter->second; fEmailList.AddChoice(addr->String()); ++iter; groupMap.erase(group); delete group; delete addr; } }