void __init_pwd_backend(void)
{
/* dev_t for the boot volume */
boot_device = dev_for_path("/boot");
/* get us an id for holding thread-specific data */
pw_tls_id = tls_allocate();
}
static const char *
getOldConfigDir( void )
{
static char * path = NULL;
if( !path )
{
#ifdef __BEOS__
char buf[MAX_PATH_LENGTH];
find_directory( B_USER_SETTINGS_DIRECTORY,
dev_for_path( "/boot" ), true,
buf, sizeof( buf ) );
path = tr_buildPath( buf, "Transmission", NULL );
#elif defined( SYS_DARWIN )
path = tr_buildPath( getHomeDir( ), "Library",
"Application Support",
"Transmission", NULL );
#elif defined( __AMIGAOS4__ )
path = tr_strdup( "PROGDIR:.transmission" );
#elif defined( WIN32 )
char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
path = tr_buildPath( appdata, "Transmission", NULL );
#else
path = tr_buildPath( getHomeDir( ), ".transmission", NULL );
#endif
}
return path;
}
fhandle_t pacFindFirst_new(char *dir, char *ext, fileinfo_t * fileinfo)
{
char dev_query[100];
fhandle_t h;
strcpy(fileinfo->dir, dir);
if (fileinfo->dir[strlen(fileinfo->dir) - 1] == '/') {
fileinfo->dir[strlen(fileinfo->dir) - 1] = 0;
}
if (ext) {
strcpy(fileinfo->ext, ext);
sprintf(file_pattern, "*.%s", fileinfo->ext);
} else {
strcpy(file_pattern, "*");
}
sprintf(dev_query, "name=%s", file_pattern);
dev_t device = dev_for_path((const char*)fileinfo->dir);
DIR* q = fs_open_query(device, dev_query, 0);
h.handle = (unsigned long)q;
if (q == NULL) {
h.handle = -1;
} else {
pacFindNext(h, fileinfo);
}
return h;
}
status_t
WorkerThread::_MirrorIndices(const BPath& sourceDirectory,
const BPath& targetDirectory) const
{
dev_t sourceDevice = dev_for_path(sourceDirectory.Path());
if (sourceDevice < 0)
return (status_t)sourceDevice;
dev_t targetDevice = dev_for_path(targetDirectory.Path());
if (targetDevice < 0)
return (status_t)targetDevice;
DIR* indices = fs_open_index_dir(sourceDevice);
if (indices == NULL) {
printf("%s: fs_open_index_dir(): (%d) %s\n", sourceDirectory.Path(),
errno, strerror(errno));
// Opening the index directory will fail for example on ISO-Live
// CDs. The default indices have already been created earlier, so
// we simply bail.
return B_OK;
}
while (dirent* index = fs_read_index_dir(indices)) {
if (strcmp(index->d_name, "name") == 0
|| strcmp(index->d_name, "size") == 0
|| strcmp(index->d_name, "last_modified") == 0) {
continue;
}
index_info info;
if (fs_stat_index(sourceDevice, index->d_name, &info) != B_OK) {
printf("Failed to mirror index %s: fs_stat_index(): (%d) %s\n",
index->d_name, errno, strerror(errno));
continue;
}
uint32 flags = 0;
// Flags are always 0 for the moment.
if (fs_create_index(targetDevice, index->d_name, info.type, flags)
!= B_OK) {
if (errno == B_FILE_EXISTS)
continue;
printf("Failed to mirror index %s: fs_create_index(): (%d) %s\n",
index->d_name, errno, strerror(errno));
continue;
}
}
fs_close_index_dir(indices);
return B_OK;
}
int
main(int argc, char **argv)
{
char *programName = argv[0];
if (strrchr(programName, '/'))
programName = strrchr(programName, '/') + 1;
bool showBlocks = false;
bool all = false;
dev_t device = -1;
while (*++argv) {
char *arg = *argv;
if (*arg == '-') {
while (*++arg && isalpha(*arg)) {
switch (arg[0]) {
case 'a':
all = true;
break;
case 'b':
showBlocks = true;
break;
default:
ShowUsage(programName);
}
}
if (arg[0] == '-') {
arg++;
if (!strcmp(arg, "all"))
all = true;
else if (!strcmp(arg, "blocks"))
showBlocks = true;
else
ShowUsage(programName);
}
} else
break;
}
// Do we already have a device? Then let's print out detailed info about that
if (argv[0] != NULL) {
PrintVerbose(dev_for_path(argv[0]));
return 0;
}
// If not, then just iterate over all devices and give a compact summary
printf("Mount Type Total Free Flags Device\n"
"--------------- -------- --------- --------- ------- --------------------------\n");
int32 cookie = 0;
while ((device = next_dev(&cookie)) >= B_OK) {
PrintCompact(device, showBlocks, all);
}
return 0;
}
int
statvfs(const char *path, struct statvfs *statvfs)
{
dev_t device = dev_for_path(path);
if (device < 0)
return -1;
return fill_statvfs(device, statvfs);
}
status_t
PackageItem::HandleAttributes(BPath *destination, BNode *node,
const char *header)
{
status_t ret = B_OK;
BVolume volume(dev_for_path(destination->Path()));
if (volume.KnowsAttr()) {
parser_debug("We have an offset\n");
if (!fPackage)
return B_ERROR;
ret = fPackage->InitCheck();
if (ret != B_OK)
return ret;
// We need to parse the data section now
fPackage->Seek(fOffset, SEEK_SET);
uint8 buffer[7];
if (fPackage->Read(buffer, 7) != 7 || memcmp(buffer, header, 5))
return B_ERROR;
parser_debug("Header validated!\n");
char *attrName = 0;
uint32 nameSize = 0;
uint8 *attrData = new uint8[P_CHUNK_SIZE];
uint64 dataSize = P_CHUNK_SIZE;
uint8 *temp = new uint8[P_CHUNK_SIZE];
uint64 tempSize = P_CHUNK_SIZE;
uint64 attrCSize = 0, attrOSize = 0;
uint32 attrType = 0; // type_code type
bool attrStarted = false, done = false;
while (fPackage->Read(buffer, 7) == 7) {
if (!memcmp(buffer, "FBeA", 5))
continue;
ret = ParseAttribute(buffer, node, &attrName, &nameSize, &attrType,
&attrData, &dataSize, &temp, &tempSize, &attrCSize, &attrOSize,
&attrStarted, &done);
if (ret != B_OK || done) {
if (ret != B_OK) {
parser_debug("_ParseAttribute failed for %s\n",
destination->Path());
}
break;
}
}
delete[] attrData;
delete[] temp;
}
return ret;
}
// mountToLocalFolder()
//
void mountToLocalFolder(char *host, char *share)
{
char *folder = makeLocalFolder(host, share);
if (folder)
{
if (dev_for_path("/boot/home") == dev_for_path(folder))
if (!mountFileShare(address, share, folder))
return;
updateMountList(host, share, folder);
showFolder(folder);
free(folder);
}
else
{
BAlert *alert = new BAlert("title", "An attempt to create a local mount point to access this shared volume has failed.", "OK");
alert->Go();
}
}
/*! \brief Finds a BPartition by mount path.
*/
status_t
BDiskDeviceRoster::FindPartitionByMountPoint(const char* mountPoint,
BDiskDevice* device, BPartition** _partition)
{
BVolume volume(dev_for_path(mountPoint));
if (volume.InitCheck() == B_OK
&& FindPartitionByVolume(volume, device, _partition))
return B_OK;
return B_ENTRY_NOT_FOUND;
}
status_t trash(const char *f)
{
status_t err;
attr_info ai;
dev_t dev = -1;
int nr;
const char *original_path;
char trash_dir[B_PATH_NAME_LENGTH];
char trashed_file[B_PATH_NAME_LENGTH];
dev = dev_for_path(f);
err = find_directory(B_TRASH_DIRECTORY, dev, false, trash_dir, B_PATH_NAME_LENGTH);
if (err < 0)
return err;
BNode node(f);
err = node.InitCheck();
if (err < 0)
return err;
err = node.GetAttrInfo(kAttrOriginalPath, &ai);
if (err == B_OK)
return EALREADY;
if (!strncmp(f, trash_dir, strlen(trash_dir)))
return EALREADY;
entry_ref er;
err = get_ref_for_path(f, &er);
if (err < 0)
return err;
BPath orgPath(&er);
err = orgPath.InitCheck();
if (err < 0)
return err;
original_path = orgPath.Path();
BDirectory trashDir(trash_dir);
err = trashDir.InitCheck();
if (err < 0)
return err;
for (nr = 0; ; nr++) {
if (nr > INT_MAX - 1)
return B_ERROR;
if (nr)
snprintf(trashed_file, B_PATH_NAME_LENGTH-1, "%s/%s %d", trash_dir, er.name, nr);
else
snprintf(trashed_file, B_PATH_NAME_LENGTH-1, "%s/%s", trash_dir, er.name);
if (!trashDir.Contains(trashed_file))
break;
}
err = rename(original_path, trashed_file);
if (err < 0)
return err;
err = node.WriteAttr(kAttrOriginalPath, B_STRING_TYPE, 0LL, original_path, strlen(original_path)+1);
if (err < 0)
return err;
return 0;
}
// AddCLVItems()
//
void AddCLVItems(ColumnListView* MyColumnListView)
{
DIR *hosts, *shares;
struct dirent *hostInfo, *shareInfo;
struct stat st;
struct tm *mountTime;
char path[B_PATH_NAME_LENGTH];
hosts = opendir(BT_HOST_PATH);
if (hosts)
{
while ((hostInfo = readdir(hosts)) != NULL)
if (IsValid(hostInfo->d_name))
{
sprintf(path, "%s/%s", BT_HOST_PATH, hostInfo->d_name);
shares = opendir(path);
if (shares)
{
while ((shareInfo = readdir(shares)) != NULL)
if (IsValid(shareInfo->d_name))
{
sprintf(path, "%s/%s/%s", BT_HOST_PATH, hostInfo->d_name, shareInfo->d_name);
if (dev_for_path("/boot/home") != dev_for_path(path))
{
// stat(path, &st);
// mountTime = localtime(&st.st_ctime);
// strftime(path, sizeof(path), "%a, %b %d %Y at %I:%M %p", mountTime);
MyColumnListView->AddItem(new MountItem(hostInfo->d_name, shareInfo->d_name, path));
}
else
rmdir(path);
}
closedir(shares);
}
}
closedir(hosts);
}
}
void
MainWindow::_Unmount(BDiskDevice* disk, partition_id selectedPartition)
{
if (!disk || selectedPartition < 0) {
_DisplayPartitionError(B_TRANSLATE("You need to select a partition "
"entry from the list."));
return;
}
BPartition* partition = disk->FindDescendant(selectedPartition);
if (!partition) {
_DisplayPartitionError(B_TRANSLATE("Unable to find the selected "
"partition by ID."));
return;
}
if (partition->IsMounted()) {
BPath path;
partition->GetMountPoint(&path);
status_t ret = partition->Unmount();
if (ret < B_OK) {
_DisplayPartitionError(
B_TRANSLATE("Could not unmount partition %s."),
partition, ret);
} else {
if (dev_for_path(path.Path()) == dev_for_path("/"))
rmdir(path.Path());
// successful unmount, adapt to the changes
_ScanDrives();
}
} else {
_DisplayPartitionError(
B_TRANSLATE("The partition %s is already unmounted."),
partition);
}
}
void
ControlsView::VolumeTabView::MessageReceived(BMessage* message)
{
switch (message->what) {
case B_NODE_MONITOR:
switch (message->FindInt32("opcode")) {
case B_DEVICE_MOUNTED:
_AddVolume(message->FindInt32("new device"));
break;
case B_DEVICE_UNMOUNTED:
_RemoveVolume(message->FindInt32("device"));
break;
}
break;
case kBtnCancel:
case kBtnRescan:
ViewForTab(Selection())->MessageReceived(message);
break;
case B_SIMPLE_DATA:
case B_REFS_RECEIVED:
{
entry_ref ref;
for (int i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
BEntry entry(&ref, true);
BPath path;
entry.GetPath(&path);
dev_t device = dev_for_path(path.Path());
for (int j = 0; VolumeTab* item = (VolumeTab*)TabAt(j); j++) {
if (item->Volume()->Device() == device) {
Select(j);
((VolumeView*)(item->View()))->SetPath(path);
break;
}
}
}
break;
}
default:
BTabView::MessageReceived(message);
break;
}
}
/* BeOS has a statvfs function, but it does not return sensible values
for f_files, f_ffree and f_favail, and lacks f_type, f_basetype and
f_fstypename. Use 'struct fs_info' instead. */
static int
statfs (char const *filename, struct fs_info *buf)
{
dev_t device = dev_for_path (filename);
if (device < 0)
{
errno = (device == B_ENTRY_NOT_FOUND ? ENOENT
: device == B_BAD_VALUE ? EINVAL
: device == B_NAME_TOO_LONG ? ENAMETOOLONG
: device == B_NO_MEMORY ? ENOMEM : device == B_FILE_ERROR ? EIO : 0);
return -1;
}
/* If successful, buf->dev will be == device. */
return fs_stat_dev (device, buf);
}
Settings::Settings()
{
fDefaultSettings.enabled = true;
fDefaultSettings.automatic = true;
system_info sysInfo;
get_system_info(&sysInfo);
fDefaultSettings.size = (off_t)sysInfo.max_pages * B_PAGE_SIZE;
if (fDefaultSettings.size <= kGigaByte) {
// Memory under 1GB? double the swap
// This matches the behaviour of the kernel
fDefaultSettings.size *= 2;
}
fDefaultSettings.volume = dev_for_path("/boot");
}
int get_fs_usage (const char *path, const char *disk, struct fs_usage *fsp)
{
int result = -1;
dev_t device = dev_for_path (path);
if (device >0) {
fs_info info;
if (fs_stat_dev (device, &info) == 0) {
fsp->fsu_blocks = adjust_blocks (info.total_blocks, info.block_size, 512);
fsp->fsu_bfree = fsp->fsu_bavail = adjust_blocks (info.free_blocks, info.block_size, 512);
fsp->fsu_files = info.total_nodes;
fsp->fsu_ffree = info.free_nodes;
result = 0;
}
}
return result;
};
int32
OggEncoder::WriteDetails(argument* args) {
PRINT(("OggEncoder::WriteDetails(argument*)\n"));
dev_t device = dev_for_path(args->outputFile);
BVolume volume(device);
if (volume.InitCheck() != B_OK) {
return B_ERROR;
}
BFile oggFile(args->outputFile, B_READ_WRITE);
if (oggFile.InitCheck() != B_OK) {
return B_ERROR;
}
if (volume.KnowsMime()) {
BNodeInfo info(&oggFile);
if (info.InitCheck() != B_OK) {
return B_ERROR;
}
if (info.SetType(OGG_MIME_TYPE) != B_OK) {
return B_ERROR;
}
}
if (volume.KnowsAttr()) {
AudioAttributes attributes(&oggFile);
attributes.SetArtist(args->artist);
attributes.SetAlbum(args->album);
attributes.SetTitle(args->title);
attributes.SetYear(args->year);
attributes.SetComment(args->comment);
attributes.SetTrack(args->track);
attributes.SetGenre(args->genre);
if (attributes.Write() != B_OK) {
return B_ERROR;
}
}
return B_OK;
}
status_t
WorkerThread::_CreateDefaultIndices(const BPath& targetDirectory) const
{
dev_t targetDevice = dev_for_path(targetDirectory.Path());
if (targetDevice < 0)
return (status_t)targetDevice;
struct IndexInfo {
const char* name;
uint32_t type;
};
const IndexInfo defaultIndices[] = {
{ "BEOS:APP_SIG", B_STRING_TYPE },
{ "BEOS:LOCALE_LANGUAGE", B_STRING_TYPE },
{ "BEOS:LOCALE_SIGNATURE", B_STRING_TYPE },
{ "_trk/qrylastchange", B_INT32_TYPE },
{ "_trk/recentQuery", B_INT32_TYPE },
{ "be:deskbar_item_status", B_STRING_TYPE }
};
uint32 flags = 0;
// Flags are always 0 for the moment.
for (uint32 i = 0; i < sizeof(defaultIndices) / sizeof(IndexInfo); i++) {
const IndexInfo& info = defaultIndices[i];
if (fs_create_index(targetDevice, info.name, info.type, flags)
!= B_OK) {
if (errno == B_FILE_EXISTS)
continue;
printf("Failed to create index %s: fs_create_index(): (%d) %s\n",
info.name, errno, strerror(errno));
return errno;
}
}
return B_OK;
}
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;
}
status_t
PackageItem::InitPath(const char *path, BPath *destination)
{
status_t ret = B_OK;
if (fPathType == P_INSTALL_PATH) {
if (!path) {
parser_debug("InitPath path is NULL\n");
return B_ERROR;
}
ret = destination->SetTo(path, fPath.String());
}
else if (fPathType == P_SYSTEM_PATH)
ret = destination->SetTo(fPath.String());
else {
if (!path) {
parser_debug("InitPath path is NULL\n");
return B_ERROR;
}
BVolume volume(dev_for_path(path));
ret = volume.InitCheck();
if (ret != B_OK)
return ret;
BDirectory temp;
ret = volume.GetRootDirectory(&temp);
if (ret != B_OK)
return ret;
BPath mountPoint(&temp, NULL);
ret = destination->SetTo(mountPoint.Path(), fPath.String());
}
return ret;
}
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;
}
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;
}
Int64 GetFreeDisk(const char *FileName)
{
#ifdef _WIN_32
char Root[NM];
GetPathRoot(FileName,Root);
typedef BOOL (WINAPI *GETDISKFREESPACEEX)(
LPCTSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER
);
static GETDISKFREESPACEEX pGetDiskFreeSpaceEx=NULL;
if (pGetDiskFreeSpaceEx==NULL)
{
HMODULE hKernel=GetModuleHandle("kernel32.dll");
if (hKernel!=NULL)
pGetDiskFreeSpaceEx=(GETDISKFREESPACEEX)GetProcAddress(hKernel,"GetDiskFreeSpaceExA");
}
if (pGetDiskFreeSpaceEx!=NULL)
{
GetFilePath(FileName,Root);
ULARGE_INTEGER uiTotalSize,uiTotalFree,uiUserFree;
uiUserFree.u.LowPart=uiUserFree.u.HighPart=0;
if (pGetDiskFreeSpaceEx(*Root ? Root:NULL,&uiUserFree,&uiTotalSize,&uiTotalFree) &&
uiUserFree.u.HighPart<=uiTotalFree.u.HighPart)
return(int32to64(uiUserFree.u.HighPart,uiUserFree.u.LowPart));
}
DWORD SectorsPerCluster,BytesPerSector,FreeClusters,TotalClusters;
if (!GetDiskFreeSpace(*Root ? Root:NULL,&SectorsPerCluster,&BytesPerSector,&FreeClusters,&TotalClusters))
return(1457664);
Int64 FreeSize=SectorsPerCluster*BytesPerSector;
FreeSize=FreeSize*FreeClusters;
return(FreeSize);
#elif defined(_BEOS)
char Root[NM];
GetFilePath(FileName,Root);
dev_t Dev=dev_for_path(*Root ? Root:".");
if (Dev<0)
return(1457664);
fs_info Info;
if (fs_stat_dev(Dev,&Info)!=0)
return(1457664);
Int64 FreeSize=Info.block_size;
FreeSize=FreeSize*Info.free_blocks;
return(FreeSize);
#elif defined(_UNIX)
return(1457664);
#elif defined(_EMX)
int Drive=(!isalpha(FileName[0]) || FileName[1]!=':') ? 0:toupper(FileName[0])-'A'+1;
if (_osmode == OS2_MODE)
{
FSALLOCATE fsa;
if (DosQueryFSInfo(Drive,1,&fsa,sizeof(fsa))!=0)
return(1457664);
Int64 FreeSize=fsa.cSectorUnit*fsa.cbSector;
FreeSize=FreeSize*fsa.cUnitAvail;
return(FreeSize);
}
else
{
union REGS regs,outregs;
memset(®s,0,sizeof(regs));
regs.h.ah=0x36;
regs.h.dl=Drive;
_int86 (0x21,®s,&outregs);
if (outregs.x.ax==0xffff)
return(1457664);
Int64 FreeSize=outregs.x.ax*outregs.x.cx;
FreeSize=FreeSize*outregs.x.bx;
return(FreeSize);
}
#else
#define DISABLEAUTODETECT
return(1457664);
#endif
}
int
main(int argc, char *argv[])
{
int directoryArgNr;
int status;
dev_t volume;
directory_which dirType;
int returnCode;
status = NO_ERRORS;
directoryArgNr = 1;
returnCode = 0;
dirType = B_BEOS_DIRECTORY; /* so that it compiles */
/* By default use boot volume*/
volume = dev_for_path("/boot");
if (argc <= 1) {
status = ARGUMENT_MISSING;
} else {
if (strcmp(argv[1], "-l") == 0 ) {
listDirectoryWhich();
return 0;
}
if (strcmp(argv[1], "-v") == 0 ) {
if (argc >= 3) {
dev_t temp_volume;
/* get volume from second arg */
temp_volume = dev_for_path(argv[2]);
/* Keep default value in case of error */
if (temp_volume >= 0)
volume = temp_volume;
/* two arguments were used for volume */
directoryArgNr+=2;
} else {
/* set status to argument missing */
status = ARGUMENT_MISSING;
}
}
}
if (status == NO_ERRORS && argc > directoryArgNr) {
/* get directory constant from next argument */
if (!retrieveDirValue(directoryTypes, argv[directoryArgNr], &dirType))
status = WRONG_DIR_TYPE;
} else {
status = ARGUMENT_MISSING;
}
/* Do the actual directoy finding */
if (status == NO_ERRORS) {
/* Question: would B_PATH_NAME_LENGTH alone have been enough? */
char buffer[B_PATH_NAME_LENGTH+B_FILE_NAME_LENGTH];
status_t result = find_directory (dirType, volume, false, buffer,
sizeof(buffer));
if (result == B_OK) {
printf("%s\n", buffer);
} else {
/* else what? */
/* this can not happen! */
fprintf(stderr, "Serious internal error; contact support\n");
}
}
/* Error messages and return code setting */
if (status == WRONG_DIR_TYPE) {
fprintf(stderr, "%s: unrecognized directory_which constant \'%s\'\n", argv[0],
argv[directoryArgNr]);
returnCode = 252;
}
if (status == ARGUMENT_MISSING) {
usageMsg();
returnCode = 255;
}
return returnCode;
}
/**
* Initialises OpenJazz.
*
* Establishes the paths from which to read files, loads configuration, sets up
* the game window and loads required data.
*
* @param argc Number of arguments, as passed to main function
* @param argv Array of argument strings, as passed to main function
*/
void startUp (int argc, char *argv[]) {
File* file;
unsigned char* pixels = NULL;
int count;
int screenW = DEFAULT_SCREEN_WIDTH;
int screenH = DEFAULT_SCREEN_HEIGHT;
int scaleFactor = 1;
#ifdef FULLSCREEN_ONLY
bool fullscreen = true;
#else
bool fullscreen = false;
#endif
// Determine paths
// Use hard-coded paths, if available
#ifdef DATAPATH
firstPath = new Path(NULL, createString(DATAPATH));
#else
firstPath = NULL;
#endif
#ifdef __HAIKU__
dev_t volume = dev_for_path("/boot");
char buffer[10 + B_PATH_NAME_LENGTH + B_FILE_NAME_LENGTH];
status_t result;
result = find_directory(B_SYSTEM_DATA_DIRECTORY,
volume, false, buffer, sizeof(buffer));
strncat(buffer, "/openjazz/", sizeof(buffer));
firstPath = new Path(firstPath, createString(buffer));
result = find_directory(B_USER_NONPACKAGED_DATA_DIRECTORY,
volume, false, buffer, sizeof(buffer));
strncat(buffer, "/openjazz/", sizeof(buffer));
firstPath = new Path(firstPath, createString(buffer));
#endif
#ifdef __SYMBIAN32__
#ifdef UIQ3
firstPath = new Path(firstPath, createString("c:\\shared\\openjazz\\"));
#else
firstPath = new Path(firstPath, createString("c:\\data\\openjazz\\"));
#endif
firstPath = new Path(firstPath, createString(KOpenJazzPath));
#endif
// Use any provided paths, appending a directory separator as necessary
for (count = 1; count < argc; count++) {
// If it isn't an option, it should be a path
if (argv[count][0] != '-') {
#ifdef _WIN32
if (argv[count][strlen(argv[count]) - 1] != '\\') {
firstPath = new Path(firstPath, createString(argv[count], "\\"));
#else
if (argv[count][strlen(argv[count]) - 1] != '/') {
firstPath = new Path(firstPath, createString(argv[count], "/"));
#endif
} else {
firstPath = new Path(firstPath, createString(argv[count]));
}
}
}
// Use the path of the program, but not on Wii as this does crash in
// dolphin emulator. Also is not needed, because CWD is used there
#ifndef WII
count = strlen(argv[0]) - 1;
// Search for directory separator
#ifdef _WIN32
while ((argv[0][count] != '\\') && (count >= 0)) count--;
#else
while ((argv[0][count] != '/') && (count >= 0)) count--;
#endif
// If a directory was found, copy it to the path
if (count > 0) {
firstPath = new Path(firstPath, new char[count + 2]);
memcpy(firstPath->path, argv[0], count + 1);
firstPath->path[count + 1] = 0;
}
#endif
// Use the user's home directory, if available
#ifdef HOMEDIR
#ifdef _WIN32
firstPath = new Path(firstPath, createString(getenv("HOME"), "\\"));
#else
firstPath = new Path(firstPath, createString(getenv("HOME"), "/."));
#endif
#endif
// Use the current working directory
firstPath = new Path(firstPath, createString(""));
// Default settings
// Sound settings
#if defined(WIZ) || defined(GP2X)
volume = 40;
#endif
// Create the network address
netAddress = createString(NET_ADDRESS);
// Load settings from config file
setup.load(&screenW, &screenH, &fullscreen, &scaleFactor);
// Get command-line override
for (count = 1; count < argc; count++) {
// If there's a hyphen, it should be an option
if (argv[count][0] == '-') {
#ifndef FULLSCREEN_ONLY
if (argv[count][1] == 'f') fullscreen = true;
#endif
if (argv[count][1] == 'm') {
setMusicVolume(0);
setSoundVolume(0);
}
}
}
// Create the game's window
canvas = NULL;
if (!video.init(screenW, screenH, fullscreen)) {
delete firstPath;
throw E_VIDEO;
}
#ifdef SCALE
video.setScaleFactor(scaleFactor);
#endif
if (SDL_NumJoysticks() > 0) SDL_JoystickOpen(0);
// Set up audio
openAudio();
// Load fonts
// Open the panel, which contains two fonts
try {
file = new File("PANEL.000", false);
} catch (int e) {
closeAudio();
delete firstPath;
log("Unable to find game data files. When launching OpenJazz, pass the location");
log("of the original game data, eg:");
log(" OpenJazz ~/jazz1");
#ifdef __HAIKU__
char alertBuffer[100+B_PATH_NAME_LENGTH+B_FILE_NAME_LENGTH];
strcpy(alertBuffer, "Unable to find game data files!\n"
"Put the data into the folder:\n");
strncat(alertBuffer, buffer, sizeof(alertBuffer));
BAlert* alert = new BAlert("OpenJazz", alertBuffer, "Exit", NULL, NULL,
B_WIDTH_AS_USUAL, B_STOP_ALERT);
alert->Go();
#endif
throw e;
}
pixels = file->loadRLE(46272);
delete file;
panelBigFont = NULL;
panelSmallFont = NULL;
font2 = NULL;
fontbig = NULL;
fontiny = NULL;
fontmn1 = NULL;
try {
panelBigFont = new Font(pixels + (40 * 320), true);
panelSmallFont = new Font(pixels + (48 * 320), false);
font2 = new Font("FONT2.0FN");
fontbig = new Font("FONTBIG.0FN");
fontiny = new Font("FONTINY.0FN");
fontmn1 = new Font("FONTMN1.0FN");
fontmn2 = new Font("FONTMN2.0FN");
} catch (int e) {
if (panelBigFont) delete panelBigFont;
if (panelSmallFont) delete panelSmallFont;
if (font2) delete font2;
if (fontbig) delete fontbig;
if (fontiny) delete fontiny;
if (fontmn1) delete fontmn1;
delete[] pixels;
closeAudio();
delete firstPath;
throw e;
}
delete[] pixels;
// Establish arbitrary timing
globalTicks = SDL_GetTicks() - 20;
// Fill trigonometric function look-up tables
for (count = 0; count < 1024; count++)
sinLut[count] = fixed(sinf(2 * PI * float(count) / 1024.0f) * 1024.0f);
// Initiate networking
net = new Network();
level = NULL;
jj2Level = NULL;
}
/**
* De-initialises OpenJazz.
*
* Frees data, writes configuration, and shuts down SDL.
*/
void shutDown () {
delete net;
delete panelBigFont;
delete panelSmallFont;
delete font2;
delete fontbig;
delete fontiny;
delete fontmn1;
delete fontmn2;
#ifdef SCALE
if (video.getScaleFactor() > 1) SDL_FreeSurface(canvas);
#endif
closeAudio();
// Save settings to config file
setup.save();
delete firstPath;
}
void
PackageView::MessageReceived(BMessage* message)
{
switch (message->what) {
case P_MSG_INSTALL:
{
fBeginButton->SetEnabled(false);
fInstallTypes->SetEnabled(false);
fDestination->SetEnabled(false);
fStatusWindow->Show();
fInstallProcess.Start();
break;
}
case P_MSG_PATH_CHANGED:
{
BString path;
if (message->FindString("path", &path) == B_OK)
fCurrentPath.SetTo(path.String());
break;
}
case P_MSG_OPEN_PANEL:
fExpectingOpenPanelResult = true;
fOpenPanel->Show();
break;
case P_MSG_INSTALL_TYPE_CHANGED:
{
int32 index;
if (message->FindInt32("index", &index) == B_OK)
_InstallTypeChanged(index);
break;
}
case P_MSG_I_FINISHED:
{
BAlert* notify = new BAlert("installation_success",
B_TRANSLATE("The package you requested has been successfully "
"installed on your system."),
B_TRANSLATE("OK"));
notify->SetFlags(notify->Flags() | B_CLOSE_ON_ESCAPE);
notify->Go();
fStatusWindow->Hide();
fBeginButton->SetEnabled(true);
fInstallTypes->SetEnabled(true);
fDestination->SetEnabled(true);
fInstallProcess.Stop();
BWindow *parent = Window();
if (parent && parent->Lock())
parent->Quit();
break;
}
case P_MSG_I_ABORT:
{
BAlert* notify = new BAlert("installation_aborted",
B_TRANSLATE(
"The installation of the package has been aborted."),
B_TRANSLATE("OK"));
notify->SetFlags(notify->Flags() | B_CLOSE_ON_ESCAPE);
notify->Go();
fStatusWindow->Hide();
fBeginButton->SetEnabled(true);
fInstallTypes->SetEnabled(true);
fDestination->SetEnabled(true);
fInstallProcess.Stop();
break;
}
case P_MSG_I_ERROR:
{
// TODO: Review this
BAlert* notify = new BAlert("installation_failed",
B_TRANSLATE("The requested package failed to install on your "
"system. This might be a problem with the target package "
"file. Please consult this issue with the package "
"distributor."),
B_TRANSLATE("OK"),
NULL, NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
fprintf(stderr,
B_TRANSLATE("Error while installing the package\n"));
notify->SetFlags(notify->Flags() | B_CLOSE_ON_ESCAPE);
notify->Go();
fStatusWindow->Hide();
fBeginButton->SetEnabled(true);
fInstallTypes->SetEnabled(true);
fDestination->SetEnabled(true);
fInstallProcess.Stop();
break;
}
case P_MSG_STOP:
{
// This message is sent to us by the PackageStatus window, informing
// user interruptions.
// We actually use this message only when a post installation script
// is running and we want to kill it while it's still running
fStatusWindow->Hide();
fBeginButton->SetEnabled(true);
fInstallTypes->SetEnabled(true);
fDestination->SetEnabled(true);
fInstallProcess.Stop();
break;
}
case B_REFS_RECEIVED:
{
if (!_ValidateFilePanelMessage(message))
break;
entry_ref ref;
if (message->FindRef("refs", &ref) == B_OK) {
BPath path(&ref);
if (path.InitCheck() != B_OK)
break;
dev_t device = dev_for_path(path.Path());
BVolume volume(device);
if (volume.InitCheck() != B_OK)
break;
BMenuItem* item = fDestField->MenuItem();
BString name = _NamePlusSizeString(path.Path(),
volume.FreeBytes(), B_TRANSLATE("%name% (%size% free)"));
item->SetLabel(name.String());
fCurrentPath.SetTo(path.Path());
}
break;
}
case B_CANCEL:
{
if (!_ValidateFilePanelMessage(message))
break;
// file panel aborted, select first suitable item
for (int32 i = 0; i < fDestination->CountItems(); i++) {
BMenuItem* item = fDestination->ItemAt(i);
BMessage* message = item->Message();
if (message == NULL)
continue;
BString path;
if (message->FindString("path", &path) == B_OK) {
fCurrentPath.SetTo(path.String());
item->SetMarked(true);
break;
}
}
break;
}
case B_SIMPLE_DATA:
if (message->WasDropped()) {
uint32 type;
int32 count;
status_t ret = message->GetInfo("refs", &type, &count);
// check whether the message means someone dropped a file
// to our view
if (ret == B_OK && type == B_REF_TYPE) {
// if it is, send it along with the refs to the application
message->what = B_REFS_RECEIVED;
be_app->PostMessage(message);
}
}
// fall-through
default:
BView::MessageReceived(message);
break;
}
}
int
main(int argc,char **argv)
{
puts("Copyright (c) 2001-2008 pinc Software.");
char *toolName = argv[0];
if (argc < 2 || !strcmp(argv[1],"--help"))
{
printUsage(toolName);
return -1;
}
while (*++argv)
{
char *arg = *argv;
if (*arg == '-')
{
while (*++arg && isalpha(*arg))
{
switch (*arg)
{
case 'i':
gDoNotCheckIndex = true;
break;
case 'f':
gDoNotCheckForFiles = true;
break;
case 'a':
gCheckAll = true;
break;
}
}
}
else
break;
}
char *attribute = argv[0];
if (!gCheckAll && attribute == NULL)
{
printUsage(toolName);
return -1;
}
dev_t device = dev_for_path(".");
if (device < B_OK)
{
fprintf(stderr,"Could not find device for current location: %s\n",strerror(device));
return -1;
}
fs_info info;
if (fs_stat_dev(device,&info) < B_OK)
{
fprintf(stderr,"Could not get stats for device: %s\n",strerror(errno));
return -1;
}
Disk disk(info.device_name);
status_t status;
if ((status = disk.InitCheck()) < B_OK)
{
fprintf(stderr,"Could not open device or file \"%s\": %s\n",info.device_name,strerror(status));
return -1;
}
if (disk.ValidateSuperBlock() < B_OK)
{
fprintf(stderr,"The disk's superblock is corrupt!\n");
return -1;
}
Directory *indices = (Directory *)Inode::Factory(&disk,disk.Indices());
if (indices == NULL || (status = indices->InitCheck()) < B_OK)
{
fprintf(stderr," Could not get indices directory: %s!\n",indices ? strerror(status) : "not found/corrupted");
delete indices;
return -1;
}
BPlusTree *tree;
if (indices->GetTree(&tree) < B_OK || tree->Validate() < B_OK)
{
fprintf(stderr," Indices B+Tree seems to be corrupt!\n");
delete indices;
return -1;
}
block_run run;
if (gCheckAll)
{
putchar('\n');
collectFiles(disk);
char name[B_FILE_NAME_LENGTH];
while (indices->GetNextEntry(name,&run) >= B_OK)
checkIndex(disk,name,run,false);
}
else if (indices->FindEntry(attribute,&run) == B_OK)
checkIndex(disk,attribute,run,true);
else
fprintf(stderr," Could not find index directory for \"%s\"!\n",attribute);
delete indices;
gHashtable.MakeEmpty(HASH_EMPTY_NONE,HASH_EMPTY_FREE);
return 0;
}
void
AutoMounter::_UnmountAndEjectVolume(BPartition* partition, BPath& mountPoint,
const char* name)
{
BDiskDevice deviceStorage;
BDiskDevice* device;
if (partition == NULL) {
// Try to retrieve partition
BDiskDeviceRoster().FindPartitionByMountPoint(mountPoint.Path(),
&deviceStorage, &partition);
device = &deviceStorage;
} else {
device = partition->Device();
}
status_t status;
if (partition != NULL)
status = partition->Unmount();
else
status = fs_unmount_volume(mountPoint.Path(), 0);
if (status != B_OK) {
if (!_SuggestForceUnmount(name, status))
return;
if (partition != NULL)
status = partition->Unmount(B_FORCE_UNMOUNT);
else
status = fs_unmount_volume(mountPoint.Path(), B_FORCE_UNMOUNT);
}
if (status != B_OK) {
_ReportUnmountError(name, status);
return;
}
if (fEjectWhenUnmounting && partition != NULL) {
// eject device if it doesn't have any mounted partitions left
class IsMountedVisitor : public BDiskDeviceVisitor {
public:
IsMountedVisitor()
:
fHasMounted(false)
{
}
virtual bool Visit(BDiskDevice* device)
{
return Visit(device, 0);
}
virtual bool Visit(BPartition* partition, int32 level)
{
if (partition->IsMounted()) {
fHasMounted = true;
return true;
}
return false;
}
bool HasMountedPartitions() const
{
return fHasMounted;
}
private:
bool fHasMounted;
} visitor;
device->VisitEachDescendant(&visitor);
if (!visitor.HasMountedPartitions())
device->Eject();
}
// remove the directory if it's a directory in rootfs
if (dev_for_path(mountPoint.Path()) == dev_for_path("/"))
rmdir(mountPoint.Path());
}
status_t
PackageView::_InstallTypeChanged(int32 index)
{
if (index < 0)
return B_ERROR;
// Clear the choice list
for (int32 i = fDestination->CountItems() - 1; i >= 0; i--) {
BMenuItem* item = fDestination->RemoveItem(i);
delete item;
}
fCurrentType = index;
pkg_profile* profile = fInfo.GetProfile(index);
if (profile == NULL)
return B_ERROR;
BString typeDescription = profile->description;
if (typeDescription.IsEmpty())
typeDescription = profile->name;
fInstallTypeDescriptionView->SetText(typeDescription.String());
BPath path;
BVolume volume;
if (profile->path_type == P_INSTALL_PATH) {
BMenuItem* item = NULL;
if (find_directory(B_SYSTEM_NONPACKAGED_DIRECTORY, &path) == B_OK) {
dev_t device = dev_for_path(path.Path());
if (volume.SetTo(device) == B_OK && !volume.IsReadOnly()
&& path.Append("apps") == B_OK) {
item = _AddDestinationMenuItem(path.Path(), volume.FreeBytes(),
path.Path());
}
}
if (item != NULL) {
item->SetMarked(true);
fCurrentPath.SetTo(path.Path());
fDestination->AddSeparatorItem();
}
_AddMenuItem(B_TRANSLATE("Other" B_UTF8_ELLIPSIS),
new BMessage(P_MSG_OPEN_PANEL), fDestination);
fDestField->SetEnabled(true);
} else if (profile->path_type == P_USER_PATH) {
bool defaultPathSet = false;
BVolumeRoster roster;
while (roster.GetNextVolume(&volume) != B_BAD_VALUE) {
BDirectory mountPoint;
if (volume.IsReadOnly() || !volume.IsPersistent()
|| volume.GetRootDirectory(&mountPoint) != B_OK) {
continue;
}
if (path.SetTo(&mountPoint, NULL) != B_OK)
continue;
char volumeName[B_FILE_NAME_LENGTH];
volume.GetName(volumeName);
BMenuItem* item = _AddDestinationMenuItem(volumeName,
volume.FreeBytes(), path.Path());
// The first volume becomes the default element
if (!defaultPathSet) {
item->SetMarked(true);
fCurrentPath.SetTo(path.Path());
defaultPathSet = true;
}
}
fDestField->SetEnabled(true);
} else
fDestField->SetEnabled(false);
return B_OK;
}
nsresult
GetSpecialSystemDirectory(SystemDirectories aSystemSystemDirectory,
nsILocalFile** aFile)
{
#if defined(XP_WIN)
WCHAR path[MAX_PATH];
#else
char path[MAXPATHLEN];
#endif
switch (aSystemSystemDirectory)
{
case OS_CurrentWorkingDirectory:
#if defined(XP_WIN)
if (!_wgetcwd(path, MAX_PATH))
return NS_ERROR_FAILURE;
return NS_NewLocalFile(nsDependentString(path),
PR_TRUE,
aFile);
#elif defined(XP_OS2)
if (DosQueryPathInfo( ".", FIL_QUERYFULLNAME, path, MAXPATHLEN))
return NS_ERROR_FAILURE;
#else
if(!getcwd(path, MAXPATHLEN))
return NS_ERROR_FAILURE;
#endif
#if !defined(XP_WIN)
return NS_NewNativeLocalFile(nsDependentCString(path),
PR_TRUE,
aFile);
#endif
case OS_DriveDirectory:
#if defined (WINCE)
{
return NS_NewLocalFile(nsDependentString(L"\\"),
PR_TRUE,
aFile);
}
#elif defined (XP_WIN)
{
PRInt32 len = ::GetWindowsDirectoryW(path, MAX_PATH);
if (len == 0)
break;
if (path[1] == PRUnichar(':') && path[2] == PRUnichar('\\'))
path[3] = 0;
return NS_NewLocalFile(nsDependentString(path),
PR_TRUE,
aFile);
}
#elif defined(XP_OS2)
{
ULONG ulBootDrive = 0;
char buffer[] = " :\\OS2\\";
DosQuerySysInfo( QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
&ulBootDrive, sizeof ulBootDrive);
buffer[0] = 'A' - 1 + ulBootDrive; // duh, 1-based index...
return NS_NewNativeLocalFile(nsDependentCString(buffer),
PR_TRUE,
aFile);
}
#else
return NS_NewNativeLocalFile(nsDependentCString("/"),
PR_TRUE,
aFile);
#endif
case OS_TemporaryDirectory:
#if defined (XP_WIN)
{
DWORD len = ::GetTempPathW(MAX_PATH, path);
if (len == 0)
break;
return NS_NewLocalFile(nsDependentString(path, len),
PR_TRUE,
aFile);
}
#elif defined(XP_OS2)
{
char *tPath = PR_GetEnv("TMP");
if (!tPath || !*tPath) {
tPath = PR_GetEnv("TEMP");
if (!tPath || !*tPath) {
// if an OS/2 system has neither TMP nor TEMP defined
// then it is severely broken, so this will never happen.
return NS_ERROR_UNEXPECTED;
}
}
nsCString tString = nsDependentCString(tPath);
if (tString.Find("/", PR_FALSE, 0, -1)) {
tString.ReplaceChar('/','\\');
}
return NS_NewNativeLocalFile(tString, PR_TRUE, aFile);
}
#elif defined(XP_MACOSX)
{
return GetOSXFolderType(kUserDomain, kTemporaryFolderType, aFile);
}
#elif defined(XP_AMIGAOS)
{
return NS_NewNativeLocalFile(nsDependentCString("T:"), PR_TRUE, aFile);
}
#elif defined(XP_UNIX) || defined(XP_BEOS)
{
static const char *tPath = nsnull;
if (!tPath) {
tPath = PR_GetEnv("TMPDIR");
if (!tPath || !*tPath) {
tPath = PR_GetEnv("TMP");
if (!tPath || !*tPath) {
tPath = PR_GetEnv("TEMP");
if (!tPath || !*tPath) {
tPath = "/tmp/";
}
}
}
}
return NS_NewNativeLocalFile(nsDependentCString(tPath),
PR_TRUE,
aFile);
}
#else
break;
#endif
#if defined (XP_WIN)
case Win_SystemDirectory:
{
#ifdef WINCE
PRUnichar winDirBuf[MAX_PATH];
nsAutoString winDir;
if (SHGetSpecialFolderPath(NULL, winDirBuf, CSIDL_WINDOWS, PR_TRUE))
winDir.Assign(winDirBuf);
else
winDir.Assign(L"\\Windows");
return NS_NewLocalFile(winDir, PR_TRUE, aFile);
#else
PRInt32 len = ::GetSystemDirectoryW(path, MAX_PATH);
// Need enough space to add the trailing backslash
if (!len || len > MAX_PATH - 2)
break;
path[len] = L'\\';
path[++len] = L'\0';
return NS_NewLocalFile(nsDependentString(path, len),
PR_TRUE,
aFile);
#endif
}
case Win_WindowsDirectory:
{
#ifdef WINCE
PRUnichar winDirBuf[MAX_PATH];
nsAutoString winDir;
if (SHGetSpecialFolderPath(NULL, winDirBuf, CSIDL_WINDOWS, PR_TRUE))
winDir.Assign(winDirBuf);
else
winDir.Assign(L"\\Windows");
return NS_NewLocalFile(winDir, PR_TRUE, aFile);
#else
PRInt32 len = ::GetWindowsDirectoryW(path, MAX_PATH);
// Need enough space to add the trailing backslash
if (!len || len > MAX_PATH - 2)
break;
path[len] = L'\\';
path[++len] = L'\0';
return NS_NewLocalFile(nsDependentString(path, len),
PR_TRUE,
aFile);
#endif
}
case Win_ProgramFiles:
{
return GetWindowsFolder(CSIDL_PROGRAM_FILES, aFile);
}
case Win_HomeDirectory:
{
PRInt32 len;
if ((len = ::GetEnvironmentVariableW(L"HOME", path, MAX_PATH)) > 0)
{
// Need enough space to add the trailing backslash
if (len > MAX_PATH - 2)
break;
path[len] = L'\\';
path[++len] = L'\0';
return NS_NewLocalFile(nsDependentString(path, len),
PR_TRUE,
aFile);
}
len = ::GetEnvironmentVariableW(L"HOMEDRIVE", path, MAX_PATH);
if (0 < len && len < MAX_PATH)
{
WCHAR temp[MAX_PATH];
DWORD len2 = ::GetEnvironmentVariableW(L"HOMEPATH", temp, MAX_PATH);
if (0 < len2 && len + len2 < MAX_PATH)
wcsncat(path, temp, len2);
len = wcslen(path);
// Need enough space to add the trailing backslash
if (len > MAX_PATH - 2)
break;
path[len] = L'\\';
path[++len] = L'\0';
return NS_NewLocalFile(nsDependentString(path, len),
PR_TRUE,
aFile);
}
}
case Win_Desktop:
{
return GetWindowsFolder(CSIDL_DESKTOP, aFile);
}
case Win_Programs:
{
return GetWindowsFolder(CSIDL_PROGRAMS, aFile);
}
case Win_Downloads:
{
// Defined in KnownFolders.h.
GUID folderid_downloads = {0x374de290, 0x123f, 0x4565, {0x91, 0x64,
0x39, 0xc4, 0x92, 0x5e, 0x46, 0x7b}};
nsresult rv = GetKnownFolder(&folderid_downloads, aFile);
// On WinXP and 2k, there is no downloads folder, default
// to 'Desktop'.
if(NS_ERROR_FAILURE == rv)
{
rv = GetWindowsFolder(CSIDL_DESKTOP, aFile);
}
return rv;
}
case Win_Controls:
{
return GetWindowsFolder(CSIDL_CONTROLS, aFile);
}
case Win_Printers:
{
return GetWindowsFolder(CSIDL_PRINTERS, aFile);
}
case Win_Personal:
{
return GetWindowsFolder(CSIDL_PERSONAL, aFile);
}
case Win_Favorites:
{
return GetWindowsFolder(CSIDL_FAVORITES, aFile);
}
case Win_Startup:
{
return GetWindowsFolder(CSIDL_STARTUP, aFile);
}
case Win_Recent:
{
return GetWindowsFolder(CSIDL_RECENT, aFile);
}
case Win_Sendto:
{
return GetWindowsFolder(CSIDL_SENDTO, aFile);
}
case Win_Bitbucket:
{
return GetWindowsFolder(CSIDL_BITBUCKET, aFile);
}
case Win_Startmenu:
{
return GetWindowsFolder(CSIDL_STARTMENU, aFile);
}
case Win_Desktopdirectory:
{
return GetWindowsFolder(CSIDL_DESKTOPDIRECTORY, aFile);
}
case Win_Drives:
{
return GetWindowsFolder(CSIDL_DRIVES, aFile);
}
case Win_Network:
{
return GetWindowsFolder(CSIDL_NETWORK, aFile);
}
case Win_Nethood:
{
return GetWindowsFolder(CSIDL_NETHOOD, aFile);
}
case Win_Fonts:
{
return GetWindowsFolder(CSIDL_FONTS, aFile);
}
case Win_Templates:
{
return GetWindowsFolder(CSIDL_TEMPLATES, aFile);
}
#ifndef WINCE
case Win_Common_Startmenu:
{
return GetWindowsFolder(CSIDL_COMMON_STARTMENU, aFile);
}
case Win_Common_Programs:
{
return GetWindowsFolder(CSIDL_COMMON_PROGRAMS, aFile);
}
case Win_Common_Startup:
{
return GetWindowsFolder(CSIDL_COMMON_STARTUP, aFile);
}
case Win_Common_Desktopdirectory:
{
return GetWindowsFolder(CSIDL_COMMON_DESKTOPDIRECTORY, aFile);
}
case Win_Printhood:
{
return GetWindowsFolder(CSIDL_PRINTHOOD, aFile);
}
case Win_Cookies:
{
return GetWindowsFolder(CSIDL_COOKIES, aFile);
}
#endif
case Win_Appdata:
{
nsresult rv = GetWindowsFolder(CSIDL_APPDATA, aFile);
#ifndef WINCE
if (NS_FAILED(rv))
rv = GetRegWindowsAppDataFolder(PR_FALSE, aFile);
#endif
return rv;
}
case Win_LocalAppdata:
{
nsresult rv = GetWindowsFolder(CSIDL_LOCAL_APPDATA, aFile);
#ifndef WINCE
if (NS_FAILED(rv))
rv = GetRegWindowsAppDataFolder(PR_TRUE, aFile);
#endif
return rv;
}
#endif // XP_WIN
#if defined(XP_AMIGAOS)
case AmigaOS_HomeDirectory:
return NS_NewNativeLocalFile(nsDependentCString("CURRENTUSER:"******"CURRENTUSER:"******"SYS:"), PR_TRUE, aFile);
case AmigaOS_DesktopDirectory:
return NS_NewNativeLocalFile(nsDependentCString("CURRENTUSER:"******"/usr/local/netscape/"),
PR_TRUE,
aFile);
case Unix_LibDirectory:
return NS_NewNativeLocalFile(nsDependentCString("/usr/local/lib/netscape/"),
PR_TRUE,
aFile);
case Unix_HomeDirectory:
return GetUnixHomeDir(aFile);
case Unix_XDG_Desktop:
case Unix_XDG_Documents:
case Unix_XDG_Download:
case Unix_XDG_Music:
case Unix_XDG_Pictures:
case Unix_XDG_PublicShare:
case Unix_XDG_Templates:
case Unix_XDG_Videos:
return GetUnixXDGUserDirectory(aSystemSystemDirectory, aFile);
#endif
#ifdef XP_BEOS
case BeOS_SettingsDirectory:
{
return GetBeOSFolder(B_USER_SETTINGS_DIRECTORY,0, aFile);
}
case BeOS_HomeDirectory:
{
return GetBeOSFolder(B_USER_DIRECTORY,0, aFile);
}
case BeOS_DesktopDirectory:
{
/* Get the user's desktop folder, which in the future may differ from the boot desktop */
char path[MAXPATHLEN];
if (find_directory(B_USER_DIRECTORY, 0, false, path, MAXPATHLEN) != B_OK )
break;
return GetBeOSFolder(B_DESKTOP_DIRECTORY, dev_for_path(path), aFile);
}
case BeOS_SystemDirectory:
{
return GetBeOSFolder(B_BEOS_DIRECTORY,0, aFile);
}
#endif
#ifdef XP_OS2
case OS2_SystemDirectory:
{
ULONG ulBootDrive = 0;
char buffer[] = " :\\OS2\\System\\";
DosQuerySysInfo( QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
&ulBootDrive, sizeof ulBootDrive);
buffer[0] = 'A' - 1 + ulBootDrive; // duh, 1-based index...
return NS_NewNativeLocalFile(nsDependentCString(buffer),
PR_TRUE,
aFile);
}
case OS2_OS2Directory:
{
ULONG ulBootDrive = 0;
char buffer[] = " :\\OS2\\";
DosQuerySysInfo( QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
&ulBootDrive, sizeof ulBootDrive);
buffer[0] = 'A' - 1 + ulBootDrive; // duh, 1-based index...
return NS_NewNativeLocalFile(nsDependentCString(buffer),
PR_TRUE,
aFile);
}
case OS2_HomeDirectory:
{
nsresult rv;
char *tPath = PR_GetEnv("MOZILLA_HOME");
char buffer[CCHMAXPATH];
/* If MOZILLA_HOME is not set, use GetCurrentProcessDirectory */
/* To ensure we get a long filename system */
if (!tPath || !*tPath) {
PPIB ppib;
PTIB ptib;
DosGetInfoBlocks( &ptib, &ppib);
DosQueryModuleName( ppib->pib_hmte, CCHMAXPATH, buffer);
*strrchr( buffer, '\\') = '\0'; // XXX DBCS misery
tPath = buffer;
}
rv = NS_NewNativeLocalFile(nsDependentCString(tPath),
PR_TRUE,
aFile);
PrfWriteProfileString(HINI_USERPROFILE, "Mozilla", "Home", tPath);
return rv;
}
case OS2_DesktopDirectory:
{
char szPath[CCHMAXPATH + 1];
BOOL fSuccess;
fSuccess = WinQueryActiveDesktopPathname (szPath, sizeof(szPath));
if (!fSuccess) {
// this could happen if we are running without the WPS, return
// the Home directory instead
return GetSpecialSystemDirectory(OS2_HomeDirectory, aFile);
}
int len = strlen (szPath);
if (len > CCHMAXPATH -1)
break;
szPath[len] = '\\';
szPath[len + 1] = '\0';
return NS_NewNativeLocalFile(nsDependentCString(szPath),
PR_TRUE,
aFile);
}
#endif
default:
break;
}
return NS_ERROR_NOT_AVAILABLE;
}