void
BNavMenu::BuildVolumeMenu()
{
BVolumeRoster roster;
BVolume volume;
roster.Rewind();
while (roster.GetNextVolume(&volume) == B_OK) {
if (!volume.IsPersistent())
continue;
BDirectory startDir;
if (volume.GetRootDirectory(&startDir) == B_OK) {
BEntry entry;
startDir.GetEntry(&entry);
Model *model = new Model(&entry);
if (model->InitCheck() != B_OK) {
delete model;
continue;
}
BNavMenu *menu = new BNavMenu(model->Name(), fMessage.what,
fMessenger, fParentWindow, fTypesList);
menu->SetNavDir(model->EntryRef());
ASSERT(menu->Name());
ModelMenuItem *item = new ModelMenuItem(model, menu);
BMessage *message = new BMessage(fMessage);
message->AddRef("refs", model->EntryRef());
item->SetMessage(message);
fItemList->AddItem(item);
ASSERT(item->Label());
}
}
}
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;
}
status_t
BPrinter::SetTo(const BDirectory& directory)
{
StopWatching();
BEntry entry;
directory.GetEntry(&entry);
entry.GetRef(&fPrinterEntryRef);
return InitCheck();
}
status_t HModuleRoster::LoadModules( BPath *moduleDirectory )
{
status_t status;
BDirectory dir;
if( (status = dir.SetTo( moduleDirectory->Path() )) == B_OK )
{
BEntry entry;
BPath modulePath;
while( dir.GetNextEntry( &entry, true ) != B_ENTRY_NOT_FOUND )
{
entry.GetPath( &modulePath );
LoadModule( &modulePath );
}
}
else
return status;
return B_OK;
}
void
delete_directory_path(char *path,bool recur)
{
BDirectory *dir;
BPath *pat,pt;
BEntry *ent;
if ((pat = create_path(path)))
{
if ((dir = create_mydir((char *)pat->Path())))
{
if (dir->Rewind() == B_OK)
{
if ((ent = new BEntry()))
{
while (dir->GetNextEntry(ent,false) == B_NO_ERROR)
{
if (ent->GetPath(&pt) == B_NO_ERROR)
{
if (recur)
{
if (ent->IsDirectory())
{
delete_directory_path((char *)pt.Path(),recur);
}
}
}
ent->Remove();
}
delete ent;
}
}
delete dir;
}
delete pat;
}
}
void
TBarWindow::MenusBeginning()
{
BPath path;
entry_ref ref;
find_directory (B_USER_DESKBAR_DIRECTORY, &path);
get_ref_for_path(path.Path(), &ref);
BEntry entry(&ref, true);
if (entry.InitCheck() == B_OK && entry.IsDirectory()) {
// need the entry_ref to the actual item
entry.GetRef(&ref);
// set the nav directory to the be folder
sBeMenu->SetNavDir(&ref);
} else if (!entry.Exists()) {
// the Be folder does not exist
// create one now
BDirectory dir;
if (entry.GetParent(&dir) == B_OK) {
BDirectory bedir;
dir.CreateDirectory("be", &bedir);
if (bedir.GetEntry(&entry) == B_OK
&& entry.GetRef(&ref) == B_OK)
sBeMenu->SetNavDir(&ref);
}
} else {
// this really should never happen
TRESPASS();
return;
}
sBeMenu->NeedsToRebuild();
sBeMenu->ResetTargets();
fBarView->SetEventMask(0);
// This works around a BeOS bug - the menu is quit with every
// B_MOUSE_DOWN the window receives...
BWindow::MenusBeginning();
}
void
TTracker::InstallTemporaryBackgroundImages()
{
// make the large Haiku Logo the default background
BPath path;
status_t status = find_directory(B_SYSTEM_DATA_DIRECTORY, &path);
if (status < B_OK) {
// TODO: this error shouldn't be shown to the regular user
BString errorMessage(B_TRANSLATE("At %func \nfind_directory() "
"failed. \nReason: %error"));
errorMessage.ReplaceFirst("%func", __PRETTY_FUNCTION__);
errorMessage.ReplaceFirst("%error", strerror(status));
BAlert* alert = new BAlert("AlertError", errorMessage.String(),
B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
return;
}
path.Append("artwork");
BString defaultBackgroundImage("/HAIKU logo - white on blue - big.png");
BDirectory dir;
if (FSGetBootDeskDir(&dir) == B_OK) {
// install a default background if there is no background defined yet
attr_info info;
if (dir.GetAttrInfo(kBackgroundImageInfo, &info) != B_OK) {
BScreen screen(B_MAIN_SCREEN_ID);
BPoint logoPos;
logoPos.x
= floorf((screen.Frame().Width() - 605) * (sqrtf(5) - 1) / 2);
logoPos.y = floorf((screen.Frame().Height() - 190) * 0.9);
BMessage message;
AddTemporaryBackgroundImages(&message,
(BString(path.Path()) << defaultBackgroundImage).String(),
BackgroundImage::kAtOffset, logoPos, 0xffffffff, false);
::InstallTemporaryBackgroundImages(&dir, &message);
}
}
}
void
BootPromptWindow::_PopulateKeymaps()
{
// Get the name of the current keymap, so we can mark the correct entry
// in the list view.
BString currentName;
entry_ref currentRef;
if (_GetCurrentKeymapRef(currentRef) == B_OK) {
BNode node(¤tRef);
node.ReadAttrString("keymap:name", ¤tName);
}
// TODO: common keymaps!
BPath path;
if (find_directory(B_SYSTEM_DATA_DIRECTORY, &path) != B_OK
|| path.Append("Keymaps") != B_OK) {
return;
}
// US-International is the default keymap, if we could not found a
// matching one
BString usInternational("US-International");
// Populate the menu
BDirectory directory;
if (directory.SetTo(path.Path()) == B_OK) {
entry_ref ref;
while (directory.GetNextRef(&ref) == B_OK) {
BMessage* message = new BMessage(MSG_KEYMAP_SELECTED);
message->AddRef("ref", &ref);
BMenuItem* item = new BMenuItem(ref.name, message);
fKeymapsMenuField->Menu()->AddItem(item);
if (currentName == ref.name)
item->SetMarked(true);
if (usInternational == ref.name)
fDefaultKeymapItem = item;
}
}
}
status_t
ThemeManager::LoadTheme(const char *path, BMessage **to)
{
status_t err;
BDirectory dir;
BFile f;
BMessage *theme;
#ifdef DEBUG_TM
PRINT(("ThemeManager::%s(%s)\n", __FUNCTION__, path));
#endif
err = dir.SetTo(path);
if (err)
fprintf(stderr, "ThemeManager:: BDirectory::SetTo 0x%08lx\n", err);
if (err) { /* not a dir, check for a zip */
// TODO
// unzip + recursive call
return err;
}
err = f.SetTo(&dir, Z_THEME_FILE_NAME, B_READ_ONLY);
if (err)
fprintf(stderr, "ThemeManager:: BFile::SetTo 0x%08lx\n", err);
if (err)
return err;
err = ParseMessageFromStream(&theme, f);
if (err)
fprintf(stderr, "ThemeManager:: ParseMessageFromStream 0x%08lx\n", err);
if (err)
return err;
err = theme->RemoveName(Z_THEME_LOCATION);
err = theme->AddString(Z_THEME_LOCATION, path);
//theme->PrintToStream();
err = AddTheme(theme);
if (err)
fprintf(stderr, "ThemeManager:: AddTheme 0x%08lx\n", err);
if (err)
delete theme;
if (!err && to)
*to = theme;
return err;
}
void
MailProtocolThread::TriggerFileMove(const entry_ref& ref, BDirectory& dir)
{
BMessage message(kMsgMoveFile);
message.AddRef("file", &ref);
BEntry entry;
dir.GetEntry(&entry);
entry_ref dirRef;
entry.GetRef(&dirRef);
message.AddRef("directory", &dirRef);
PostMessage(&message);
}
void
AddOnManager::_GetReaders(const BPath& path, entry_ref* outRefs,
int32* outCount, int32 maxCount)
{
node_ref nref;
BDirectory directory;
if (directory.SetTo(path.Path()) != B_OK
|| directory.GetNodeRef(&nref) != B_OK) {
return;
}
reader_info* info;
for (fReaderList.Rewind(); fReaderList.GetNext(&info)
&& *outCount < maxCount;) {
if (info->ref.directory != nref.node)
continue;
outRefs[*outCount] = info->ref;
(*outCount)++;
}
}
/* isProject
* checks if an selected folder is a lava project folder.
*/
bool
ProjectTypeSelector::isProject()
{
BNode objNode;
BString *Project = (BString*)FileList->FirstItem();
objNode.SetTo(Project->String());
char buffer[500];
memset(buffer, 0, sizeof(buffer));
if(objNode.ReadAttr("LAVA:Type", B_STRING_TYPE, 0, buffer, sizeof(buffer)) == B_ENTRY_NOT_FOUND)
return false;
else {
BDirectory objDir;
objDir.SetTo(Project->String());
if(objDir.InitCheck() != B_OK)
return false;
else
return true;
}
}
// OpenModuleList
module_name_list *
ModuleManager::OpenModuleList(const char *prefix, const char *suffix)
{
module_name_list *list = NULL;
if (prefix) {
list = new module_name_list;
_FindBuiltInModules(prefix, suffix, list);
for (int32 i = 0; gModuleDirs[i]; i++) {
BPath path;
BDirectory dir;
if (path.SetTo(gModuleDirs[i], prefix) == B_OK
&& dir.SetTo(path.Path()) == B_OK) {
_FindModules(dir, gModuleDirs[i], suffix, list);
}
}
list->it = list->names.begin();
}
return list;
}
void
DialUpView::LoadInterfaces()
{
fInterfaceMenu->AddSeparatorItem();
fInterfaceMenu->AddItem(new BMenuItem(kLabelCreateNewInterface,
new BMessage(kMsgCreateNew)));
fDeleterItem = new BMenuItem(kLabelDeleteCurrent,
new BMessage(kMsgDeleteCurrent));
fInterfaceMenu->AddItem(fDeleterItem);
BDirectory settingsDirectory;
BEntry entry;
BPath path;
GetPPPDirectories(&settingsDirectory, NULL);
while(settingsDirectory.GetNextEntry(&entry) == B_OK) {
if(entry.IsFile()) {
entry.GetPath(&path);
AddInterface(path.Leaf(), true);
}
}
}
void
TMailApp::_CheckForSpamFilterExistence()
{
// Looks at the filter settings to see if the user is using a spam filter.
// If there is one there, set fShowSpamGUI to TRUE, otherwise to FALSE.
int32 addonNameIndex;
const char *addonNamePntr;
BDirectory inChainDir;
BPath path;
BEntry settingsEntry;
BFile settingsFile;
BMessage settingsMessage;
fShowSpamGUI = false;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
return;
// TODO use new settings
path.Append("Mail/chains/inbound");
if (inChainDir.SetTo(path.Path()) != B_OK)
return;
while (inChainDir.GetNextEntry (&settingsEntry, true /* traverse */) == B_OK) {
if (!settingsEntry.IsFile())
continue;
if (settingsFile.SetTo (&settingsEntry, B_READ_ONLY) != B_OK)
continue;
if (settingsMessage.Unflatten (&settingsFile) != B_OK)
continue;
for (addonNameIndex = 0; B_OK == settingsMessage.FindString (
"filter_addons", addonNameIndex, &addonNamePntr);
addonNameIndex++) {
if (strstr (addonNamePntr, "Spam Filter") != NULL) {
fShowSpamGUI = true; // Found it!
return;
}
}
}
}
void SysAddDiskPrefs(void)
{
// Let BeOS scan for HFS drives
D(bug("Looking for Mac volumes...\n"));
system("mountvolume -allhfs");
// Add all HFS volumes
int32 i = 0;
dev_t d;
fs_info info;
while ((d = next_dev(&i)) >= 0) {
fs_stat_dev(d, &info);
status_t err = -1;
BPath mount;
if (!strcmp(info.fsh_name, "hfs")) {
BDirectory dir;
BEntry entry;
node_ref node;
node.device = info.dev;
node.node = info.root;
err = dir.SetTo(&node);
if (!err)
err = dir.GetEntry(&entry);
if (!err)
err = entry.GetPath(&mount);
}
if (!err)
err = unmount(mount.Path());
if (!err) {
char dev_name[B_FILE_NAME_LENGTH];
if (info.flags & B_FS_IS_READONLY) {
dev_name[0] = '*';
dev_name[1] = 0;
} else
dev_name[0] = 0;
strcat(dev_name, info.device_name);
PrefsAddString("disk", dev_name);
}
}
}
bool
DialUpView::SaveSettingsToFile()
{
bool settingsChanged, profileChanged;
IsModified(&settingsChanged, &profileChanged);
if(!settingsChanged && !profileChanged)
return true;
BMessage settings, profile;
if(!SaveSettings(&settings, &profile, false))
return false;
BDirectory settingsDirectory;
BDirectory profileDirectory;
GetPPPDirectories(&settingsDirectory, &profileDirectory);
if(settingsDirectory.InitCheck() != B_OK || profileDirectory.InitCheck() != B_OK)
return false;
BFile file;
if(settingsChanged) {
settingsDirectory.CreateFile(fCurrentItem->Label(), &file);
WriteMessageDriverSettings(file, settings);
}
if(profileChanged) {
profileDirectory.CreateFile(fCurrentItem->Label(), &file);
WriteMessageDriverSettings(file, profile);
}
return true;
}
void
VirtualKeyboardWindow::_LoadLayoutMenu(BMenu* menu, BDirectory directory)
{
entry_ref ref;
while (directory.GetNextRef(&ref) == B_OK) {
if (menu->FindItem(ref.name) != NULL)
continue;
BDirectory subdirectory;
subdirectory.SetTo(&ref);
if (subdirectory.InitCheck() == B_OK) {
BMenu* submenu = new BMenu(ref.name);
_LoadLayoutMenu(submenu, subdirectory);
menu->AddItem(submenu);
} else {
//BMessage* message = new BMessage(kChangeKeyboardLayout);
//message->AddRed("ref",&ref);
menu->AddItem(new BMenuItem(ref.name, NULL));
}
}
}
int32_t
PDirectoryCreateDirectory(void *pobject, void *in, void *out, void *extraData)
{
if (!pobject || !in || !out)
return B_ERROR;
PDirectory *parent = static_cast<PDirectory*>(pobject);
if (!parent)
return B_BAD_TYPE;
BDirectory *backend = (BDirectory*)parent->GetBackend();
PArgs *args = static_cast<PArgs*>(in), *outArgs = static_cast<PArgs*>(out);
BString path;
if (args->FindString("path", &path) != B_OK)
return B_ERROR;
BDirectory newDir;
status_t status = backend->CreateDirectory(path.String(), &newDir);
outArgs->MakeEmpty();
if (status == B_OK)
{
BEntry entry;
status = newDir.GetEntry(&entry);
if (status == B_OK)
{
BPath dirPath;
status = entry.GetPath(&dirPath);
outArgs->AddString("path", dirPath.Path());
}
}
outArgs->AddInt32("status", status);
return B_OK;
}
void
VirtualKeyboardWindow::_LoadLayouts(BMenu* menu)
{
directory_which dataDirectories[] = {
B_USER_NONPACKAGED_DATA_DIRECTORY,
B_USER_DATA_DIRECTORY,
B_SYSTEM_NONPACKAGED_DIRECTORY,
B_SYSTEM_DATA_DIRECTORY,
};
for (uint i = 0; i < sizeof(dataDirectories)/sizeof(directory_which); i++) {
BPath path;
if (find_directory(dataDirectories[i], &path) != B_OK)
continue;
path.Append("KeyboardLayouts");
BDirectory directory;
if (directory.SetTo(path.Path()) == B_OK)
_LoadLayoutMenu(menu, directory);
}
}
void
KeymapWindow::_AddKeyboardLayouts(BMenu* menu)
{
directory_which dataDirectories[] = {
B_USER_DATA_DIRECTORY,
B_COMMON_DATA_DIRECTORY,
B_BEOS_DATA_DIRECTORY
};
for (uint32 i = 0;
i < sizeof(dataDirectories) / sizeof(dataDirectories[0]); i++) {
BPath path;
if (find_directory(dataDirectories[i], &path) != B_OK)
continue;
path.Append("KeyboardLayouts");
BDirectory directory;
if (directory.SetTo(path.Path()) == B_OK)
_AddKeyboardLayoutMenu(menu, directory);
}
}
void
PersonWindow::SaveAs(int32 format)
{
if (format == 0)
format = B_PERSON_FORMAT;
char name[B_FILE_NAME_LENGTH];
_GetDefaultFileName(name);
if (fPanel == NULL) {
BPath path;
BMessenger target(this);
BMessage msg(B_SAVE_REQUESTED);
msg.AddInt32("format", format);
fPanel = new BFilePanel(B_SAVE_PANEL, &target, NULL, 0, true, &msg);
find_directory(B_USER_DIRECTORY, &path, true);
BDirectory dir;
dir.SetTo(path.Path());
BEntry entry;
if (dir.FindEntry("people", &entry) == B_OK
|| (dir.CreateDirectory("people", &dir) == B_OK
&& dir.GetEntry(&entry) == B_OK)) {
fPanel->SetPanelDirectory(&entry);
}
}
if (fPanel->Window()->Lock()) {
fPanel->SetSaveText(name);
if (fPanel->Window()->IsHidden())
fPanel->Window()->Show();
else
fPanel->Window()->Activate();
fPanel->Window()->Unlock();
}
}
void
FileTypes::ArgvReceived(int32 argc, char** argv)
{
if (argc == 3 && strcmp(argv[1], "-type") == 0) {
fArgvType = argv[2];
return;
}
BMessage* message = CurrentMessage();
BDirectory currentDirectory;
if (message != NULL)
currentDirectory.SetTo(message->FindString("cwd"));
BMessage refs;
for (int i = 1 ; i < argc ; i++) {
BPath path;
if (argv[i][0] == '/')
path.SetTo(argv[i]);
else
path.SetTo(¤tDirectory, argv[i]);
status_t status;
entry_ref ref;
BEntry entry;
if ((status = entry.SetTo(path.Path(), false)) != B_OK
|| (status = entry.GetRef(&ref)) != B_OK) {
fprintf(stderr, "Could not open file \"%s\": %s\n",
path.Path(), strerror(status));
continue;
}
refs.AddRef("refs", &ref);
}
RefsReceived(&refs);
}
void
TTracker::InstallTemporaryBackgroundImages()
{
// make the large Haiku Logo the default background
BPath path;
status_t status = find_directory(B_SYSTEM_DATA_DIRECTORY, &path);
if (status < B_OK) {
BString errorMessage;
errorMessage << "At " << __PRETTY_FUNCTION__ << "\n";
errorMessage << "find_directory() failed. \nReason: ";
errorMessage << strerror(status);
(new BAlert("AlertError", errorMessage.String(), "OK", NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT))->Go();
return;
}
path.Append("artwork");
BString defaultBackgroundImage("/HAIKU logo - white on blue - big.png");
BDirectory dir;
if (FSGetBootDeskDir(&dir) == B_OK) {
// install a default background if there is no background defined yet
attr_info info;
if (dir.GetAttrInfo(kBackgroundImageInfo, &info) != B_OK) {
BScreen screen(B_MAIN_SCREEN_ID);
BPoint logoPos;
logoPos.x
= floorf((screen.Frame().Width() - 605) * (sqrtf(5) - 1) / 2);
logoPos.y = floorf((screen.Frame().Height() - 190) * 0.9);
BMessage message;
AddTemporaryBackgroundImages(&message,
(BString(path.Path()) << defaultBackgroundImage).String(),
BackgroundImage::kAtOffset, logoPos, 0xffffffff, false);
::InstallTemporaryBackgroundImages(&dir, &message);
}
}
}
//---------------------------------------------------------------------
// HandleDirectory
//---------------------------------------------------------------------
// iterate through the directory and pass the resulting
// refs and attempt to add the resulting file
//
status_t TQueueDialog::HandleDirectory(entry_ref &ref, struct stat &st, BDirectory &dir)
{
struct stat s;
BEntry entry;
dir.Rewind();
while (true)
{
if (dir.GetNextEntry(&entry) == B_OK)
{
entry.GetStat(&s);
entry_ref eRef;
entry.GetRef(&eRef);
// HandleFile(eRef, s);
EvaluateRef(eRef);
} else
break;
}
return B_ERROR;
}
status_t
PDirectory::GetProperty(const char *name, PValue *value, const int32 &index) const
{
if (!name || !value)
return B_ERROR;
BString str(name);
PProperty *prop = FindProperty(name,index);
if (!prop)
return B_NAME_NOT_FOUND;
BDirectory *backend = (BDirectory*)fBackend;
if (str.ICompare("IsRoot") == 0)
((BoolProperty*)prop)->SetValue(backend->IsRootDirectory());
else if (str.ICompare("EntryCount") == 0)
((IntProperty*)prop)->SetValue(backend->CountEntries());
else
{
return PNode::GetProperty(name, value, index);
}
return prop->GetValue(value);
}
void
Model::ResetIconFrom()
{
BModelOpener opener(this);
if (InitCheck() != B_OK)
return;
// mirror the logic from FinishSettingUpType
if ((fBaseType == kDirectoryNode || fBaseType == kVolumeNode
|| fBaseType == kTrashNode || fBaseType == kDesktopNode)
&& !CheckNodeIconHint(fNode)) {
BDirectory* directory = dynamic_cast<BDirectory*>(fNode);
if (WellKnowEntryList::Match(NodeRef()) > (directory_which)-1) {
fIconFrom = kTrackerSupplied;
return;
} else if (directory != NULL && directory->IsRootDirectory()) {
fIconFrom = kVolume;
return;
}
}
fIconFrom = kUnknownSource;
}
void
KeymapWindow::_FillSystemMaps()
{
BListItem *item;
while ((item = fSystemListView->RemoveItem(static_cast<int32>(0))))
delete item;
// TODO: common keymaps!
BPath path;
if (find_directory(B_SYSTEM_DATA_DIRECTORY, &path) != B_OK)
return;
path.Append("Keymaps");
BDirectory directory;
entry_ref ref;
if (directory.SetTo(path.Path()) == B_OK) {
while (directory.GetNextRef(&ref) == B_OK) {
fSystemListView->AddItem(new KeymapListItem(ref));
}
}
}
BFile*
MilkySettingsApplication::_OpenSettingsFile(uint32 openMode)
{
BPath path;
find_directory(B_USER_SETTINGS_DIRECTORY, &path);
path.Append("MilkyTracker");
BEntry dirEntry(path.Path());
if (!dirEntry.Exists()) {
// MilkyTracker settings dir doesn't exist, create it
BDirectory temp;
temp.CreateDirectory(path.Path(), NULL);
}
path.Append("platform_settings");
BFile* file = new BFile(path.Path(), openMode);
if (file->InitCheck() != B_OK) {
delete file;
return NULL;
}
return file;
}
void
ServerApp::_LaunchAddOnServer()
{
// Try to launch media_addon_server by mime signature.
// If it fails (for example on the Live CD, where the executable
// hasn't yet been mimesetted), try from this application's
// directory
status_t err = be_roster->Launch(B_MEDIA_ADDON_SERVER_SIGNATURE);
if (err == B_OK)
return;
app_info info;
BEntry entry;
BDirectory dir;
entry_ref ref;
err = GetAppInfo(&info);
err |= entry.SetTo(&info.ref);
err |= entry.GetParent(&entry);
err |= dir.SetTo(&entry);
err |= entry.SetTo(&dir, "media_addon_server");
err |= entry.GetRef(&ref);
if (err == B_OK)
be_roster->Launch(&ref);
if (err == B_OK)
return;
BAlert* alert = new BAlert("media_server", "Launching media_addon_server "
"failed.\n\nmedia_server will terminate", "OK");
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
fprintf(stderr, "Launching media_addon_server (%s) failed: %s\n",
B_MEDIA_ADDON_SERVER_SIGNATURE, strerror(err));
exit(1);
}
