src/BeOS/sys_beos.cpp

/*
 *  sys_beos.cpp - System dependent routines, BeOS implementation
 *
 *  Basilisk II (C) 1997-1999 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <StorageKit.h>
#include <InterfaceKit.h>
#include <kernel/fs_info.h>
#include <drivers/Drivers.h>
#include <device/scsi.h>

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

#include "sysdeps.h"
#include "main.h"
#include "macos_util.h"
#include "prefs.h"
#include "user_strings.h"
#include "sys.h"

#define DEBUG 0
#include "debug.h"


// File handles are pointers to these structures
struct file_handle {
        file_handle *next;      // Pointer to next file handle (must be first in struct!)
        const char *name;       // File/device name (copied, for mount menu)
        int fd;                         // fd of file/device
        bool is_file;           // Flag: plain file or /dev/something?
        bool read_only;         // Copy of Sys_open() flag
        loff_t start_byte;      // Size of file header (if any)
        loff_t file_size;       // Size of file data (only valid if is_file is true)
};

// Linked list of file handles
static file_handle *first_file_handle;

// Temporary buffer for transfers from/to kernel space
const int TMP_BUF_SIZE = 0x10000;
static uint8 *tmp_buf;

// For B_SCSI_PREVENT_ALLOW
static const int32 PREVENT = 1;
static const int32 ALLOW = 0;


/*
 *  Check if device is a mounted HFS volume, get mount name
 */

static bool is_drive_mounted(const char *dev_name, char *mount_name)
{
        int32 i = 0;
        dev_t d;
        fs_info info;
        while ((d = next_dev(&i)) >= 0) {
                fs_stat_dev(d, &info);
                if (strcmp(dev_name, info.device_name) == 0) {
                        status_t err = -1;
                        BPath mount;
                        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) {
                                strcpy(mount_name, mount.Path());
                                return true;
                        }
                }
        }
        return false;
}


/*
 *  Initialization
 */

void SysInit(void)
{
        first_file_handle = NULL;

        // Allocate temporary buffer
        tmp_buf = new uint8[TMP_BUF_SIZE];
}


/*
 *  Deinitialization
 */

void SysExit(void)
{
        delete[] tmp_buf;
}


/*
 *  Create menu of used volumes (for "mount" menu)
 */

void SysCreateVolumeMenu(BMenu *menu, uint32 msg)
{
        for (file_handle *fh=first_file_handle; fh; fh=fh->next)
                if (!SysIsFixedDisk(fh))
                        menu->AddItem(new BMenuItem(fh->name, new BMessage(msg)));
}


/*
 *  Mount volume given name from mount menu
 */

void SysMountVolume(const char *name)
{
        file_handle *fh;
        for (fh=first_file_handle; fh && strcmp(fh->name, name); fh=fh->next) ;
        if (fh)
                MountVolume(fh);
}


/*
 *  This gets called when no "floppy" prefs items are found
 *  It scans for available floppy drives and adds appropriate prefs items
 */

void SysAddFloppyPrefs(void)
{
        // Only one floppy drive under BeOS
        PrefsAddString("floppy", "/dev/disk/floppy/raw");
}


/*
 *  This gets called when no "disk" prefs items are found
 *  It scans for available HFS volumes and adds appropriate prefs items
 */

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);
                }
        }
}


/*
 *  This gets called when no "cdrom" prefs items are found
 *  It scans for available CD-ROM drives and adds appropriate prefs items
 */

// Scan directory for CD-ROM drives, add them to prefs
static void scan_for_cdrom_drives(const char *directory)
{
        // Set directory
        BDirectory dir;
        dir.SetTo(directory);
        if (dir.InitCheck() != B_NO_ERROR)
                return;
        dir.Rewind();

        // Scan each entry
        BEntry entry;
        while (dir.GetNextEntry(&entry) >= 0) {

                // Get path and ref for entry
                BPath path;
                if (entry.GetPath(&path) != B_NO_ERROR)
                        continue;
                const char *name = path.Path();
                entry_ref e;
                if (entry.GetRef(&e) != B_NO_ERROR)
                        continue;

                // Recursively enter subdirectories (except for floppy)
                if (entry.IsDirectory()) {
                        if (!strcmp(e.name, "floppy"))
                                continue;
                        scan_for_cdrom_drives(name);
                } else {

                        D(bug(" checking '%s'\n", name));

                        // Ignore partitions
                        if (strcmp(e.name, "raw"))
                                continue;

                        // Open device
                        int fd = open(name, O_RDONLY);
                        if (fd < 0)
                                continue;

                        // Get geometry and device type
                        device_geometry g;
                        if (ioctl(fd, B_GET_GEOMETRY, &g, sizeof(g)) < 0) {
                                close(fd);
                                continue;
                        }

                        // Insert to list if it is a CD drive
                        if (g.device_type == B_CD)
                                PrefsAddString("cdrom", name);
                        close(fd);
                }
        }
}

void SysAddCDROMPrefs(void)
{
        // Don't scan for drives if nocdrom option given
        if (PrefsFindBool("nocdrom"))
                return;

        // Look for CD-ROM drives and add prefs items
        D(bug("Looking for CD-ROM drives...\n"));
        scan_for_cdrom_drives("/dev/disk");
}


/*
 *  Add default serial prefs (must be added, even if no ports present)
 */

void SysAddSerialPrefs(void)
{
        system_info info;
        get_system_info(&info);
        switch (info.platform_type) {
                case B_BEBOX_PLATFORM:
                case B_AT_CLONE_PLATFORM:
                        PrefsAddString("seriala", "serial1");
                        PrefsAddString("serialb", "serial2");
                        break;
                case B_MAC_PLATFORM:
                        PrefsAddString("seriala", "modem");
                        PrefsAddString("serialb", "printer");
                        break;
                default:
                        PrefsAddString("seriala", "none");
                        PrefsAddString("serialb", "none");
                        break;
        }
}


/*
 *  Open file/device, create new file handle (returns NULL on error)
 */

void *Sys_open(const char *name, bool read_only)
{
        static bool published_all = false;
        bool is_file = (strstr(name, "/dev/") != name);

        D(bug("Sys_open(%s, %s)\n", name, read_only ? "read-only" : "read/write"));

        // Print warning message and eventually unmount drive when this is an HFS volume mounted under BeOS (double mounting will corrupt the volume)
        char mount_name[B_FILE_NAME_LENGTH];
        if (!is_file && !read_only && is_drive_mounted(name, mount_name)) {
                char str[256 + B_FILE_NAME_LENGTH];
                sprintf(str, GetString(STR_VOLUME_IS_MOUNTED_WARN), mount_name);
                WarningAlert(str);
                if (unmount(mount_name) != 0) {
                        sprintf(str, GetString(STR_CANNOT_UNMOUNT_WARN), mount_name);
                        WarningAlert(str);
                        return NULL;
                }
        }

        int fd = open(name, read_only ? O_RDONLY : O_RDWR);
        if (fd < 0 && !published_all) {
                // Open failed, create all device nodes and try again, but only the first time
                system("mountvolume -publishall");
                published_all = true;
                fd = open(name, read_only ? O_RDONLY : O_RDWR);
        }
        if (fd >= 0) {
                file_handle *fh = new file_handle;
                fh->name = strdup(name);
                fh->fd = fd;
                fh->is_file = is_file;
                fh->read_only = read_only;
                fh->start_byte = 0;
                if (fh->is_file) {
                        // Detect disk image file layout
                        loff_t size = lseek(fd, 0, SEEK_END);
                        uint8 data[256];
                        lseek(fd, 0, SEEK_SET);
                        read(fd, data, 256);
                        FileDiskLayout(size, data, fh->start_byte, fh->file_size);
                }

                // Enqueue file handle
                fh->next = NULL;
                file_handle *q = first_file_handle;
                if (q) {
                        while (q->next)
                                q = q->next;
                        q->next = fh;
                } else
                        first_file_handle = fh;
                return fh;
        } else
                return NULL;
}


/*
 *  Close file/device, delete file handle
 */

void Sys_close(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        // Free device name and close file/device
        free((void *)fh->name);
        close(fh->fd);

        // Dequeue file handle
        file_handle *q = first_file_handle;
        if (q == fh) {
                first_file_handle = NULL;
                delete fh;
                return;
        }
        while (q) {
                if (q->next == fh) {
                        q->next = fh->next;
                        delete fh;
                        return;
                }
                q = q->next;
        }
}


/*
 *  Read "length" bytes from file/device, starting at "offset", to "buffer",
 *  returns number of bytes read (or 0)
 */

static inline ssize_t sread(int fd, void *buf, size_t count)
{
        ssize_t res;
        while ((res = read(fd, buf, count)) == B_INTERRUPTED) ;
        return res;
}

size_t Sys_read(void *arg, void *buffer, loff_t offset, size_t length)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return 0;

//      D(bug("Sys_read(%08lx, %08lx, %Ld, %d)\n", fh, buffer, offset, length));

        // Seek to position
        if (lseek(fh->fd, offset + fh->start_byte, SEEK_SET) < 0)
                return 0;

        // Buffer in kernel space?
        size_t actual = 0;
        if ((uint32)buffer < 0x80000000) {

                // Yes, transfer via buffer
                while (length) {
                        size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
                        if (sread(fh->fd, tmp_buf, transfer_size) != transfer_size)
                                return actual;
                        memcpy(buffer, tmp_buf, transfer_size);
                        buffer = (void *)((uint8 *)buffer + transfer_size);
                        length -= transfer_size;
                        actual += transfer_size;
                }

        } else {

                // No, transfer directly
                actual = sread(fh->fd, buffer, length);
                if (actual < 0)
                        actual = 0;
        }
        return actual;
}


/*
 *  Write "length" bytes from "buffer" to file/device, starting at "offset",
 *  returns number of bytes written (or 0)
 */

static inline ssize_t swrite(int fd, void *buf, size_t count)
{
        ssize_t res;
        while ((res = write(fd, buf, count)) == B_INTERRUPTED) ;
        return res;
}

size_t Sys_write(void *arg, void *buffer, loff_t offset, size_t length)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return 0;

//      D(bug("Sys_write(%08lx, %08lx, %Ld, %d)\n", fh, buffer, offset, length));

        // Seek to position
        if (lseek(fh->fd, offset + fh->start_byte, SEEK_SET) < 0)
                return 0;

        // Buffer in kernel space?
        size_t actual = 0;
        if ((uint32)buffer < 0x80000000) {

                // Yes, transfer via buffer
                while (length) {
                        size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
                        memcpy(tmp_buf, buffer, transfer_size);
                        if (swrite(fh->fd, tmp_buf, transfer_size) != transfer_size)
                                return actual;
                        buffer = (void *)((uint8 *)buffer + transfer_size);
                        length -= transfer_size;
                        actual += transfer_size;
                }

        } else {

                // No, transfer directly
                actual = swrite(fh->fd, buffer, length);
                if (actual < 0)
                        actual = 0;
        }
        return actual;
}


/*
 *  Return size of file/device (minus header)
 */

loff_t SysGetFileSize(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return true;

        if (fh->is_file)
                return fh->file_size;
        else {
                device_geometry g;
                if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
                        return (loff_t)g.bytes_per_sector * g.sectors_per_track * g.cylinder_count * g.head_count;
                else
                        return 0;
        }
}


/*
 *  Eject volume (if applicable)
 */

void SysEject(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        if (!fh->is_file)
                ioctl(fh->fd, B_EJECT_DEVICE);
}


/*
 *  Format volume (if applicable)
 */

bool SysFormat(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file)
                return ioctl(fh->fd, B_FORMAT_DEVICE) >= 0;
        else
                return false;
}


/*
 *  Check if file/device is read-only (this includes the read-only flag on Sys_open())
 */

bool SysIsReadOnly(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return true;

        if (fh->is_file) {

                // File, return flag given to Sys_open
                return fh->read_only;

        } else {

                // Device, check write protection
                device_geometry g;
                if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
                        return g.read_only | fh->read_only;
                else
                        return fh->read_only;   // Removable but not inserted
        }
}


/*
 *  Check if the given file handle refers to a fixed or a removable disk
 */

bool SysIsFixedDisk(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return true;

        if (fh->is_file)
                return true;
        else {
                device_geometry g;
                if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
                        return !g.removable;
                else
                        return false;   // Removable but not inserted
        }
}


/*
 *  Check if a disk is inserted in the drive (always true for files)
 */

bool SysIsDiskInserted(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (fh->is_file)
                return true;
        else {
                status_t l;
                if (ioctl(fh->fd, B_GET_MEDIA_STATUS, &l, sizeof(l)) >= 0 && l == B_NO_ERROR)
                        return true;
                else
                        return false;
        }
}


/*
 *  Prevent medium removal (if applicable)
 */

void SysPreventRemoval(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        if (!fh->is_file)
                ioctl(fh->fd, B_SCSI_PREVENT_ALLOW, &PREVENT, sizeof(PREVENT));
}


/*
 *  Allow medium removal (if applicable)
 */

void SysAllowRemoval(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        if (!fh->is_file)
                ioctl(fh->fd, B_SCSI_PREVENT_ALLOW, &ALLOW, sizeof(ALLOW));
}


/*
 *  Read CD-ROM TOC (binary MSF format, 804 bytes max.)
 */

bool SysCDReadTOC(void *arg, uint8 *toc)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file) {
                memset(tmp_buf, 0, 804);
                if (ioctl(fh->fd, B_SCSI_GET_TOC, tmp_buf, 804) < 0)
                        return false;
                memcpy(toc, tmp_buf, 804);
                return true;
        } else
                return false;
}


/*
 *  Read CD-ROM position data (Sub-Q Channel, 16 bytes, see SCSI standard)
 */

bool SysCDGetPosition(void *arg, uint8 *pos)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file) {
                if (ioctl(fh->fd, B_SCSI_GET_POSITION, tmp_buf, 16) < 0)
                        return false;
                memcpy(pos, tmp_buf, 16);
                return true;
        } else
                return false;
}


/*
 *  Play CD audio
 */

bool SysCDPlay(void *arg, uint8 start_m, uint8 start_s, uint8 start_f, uint8 end_m, uint8 end_s, uint8 end_f)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file) {
                scsi_play_position *p = (scsi_play_position *)tmp_buf;
                p->start_m = start_m;
                p->start_s = start_s;
                p->start_f = start_f;
                p->end_m = end_m;
                p->end_s = end_s;
                p->end_f = end_f;
                return ioctl(fh->fd, B_SCSI_PLAY_POSITION, p, sizeof(scsi_play_position)) == 0;
        } else
                return false;
}


/*
 *  Pause CD audio
 */

bool SysCDPause(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return true;

        if (!fh->is_file)
                return ioctl(fh->fd, B_SCSI_PAUSE_AUDIO) == 0;
        else
                return false;
}


/*
 *  Resume paused CD audio
 */

bool SysCDResume(void *arg)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file)
                return ioctl(fh->fd, B_SCSI_RESUME_AUDIO) == 0;
        else
                return false;
}


/*
 *  Stop CD audio
 */

bool SysCDStop(void *arg, uint8 lead_out_m, uint8 lead_out_s, uint8 lead_out_f)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file)
                return ioctl(fh->fd, B_SCSI_STOP_AUDIO) == 0;
        else
                return false;
}


/*
 *  Perform CD audio fast-forward/fast-reverse operation starting from specified address
 */

bool SysCDScan(void *arg, uint8 start_m, uint8 start_s, uint8 start_f, bool reverse)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return false;

        if (!fh->is_file) {
                scsi_scan *p = (scsi_scan *)tmp_buf;
                p->speed = 0;
                p->direction = reverse ? -1 : 1;
                return ioctl(fh->fd, B_SCSI_SCAN, p, sizeof(scsi_scan)) == 0;
        } else
                return false;
}


/*
 *  Set CD audio volume (0..255 each channel)
 */

void SysCDSetVolume(void *arg, uint8 left, uint8 right)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        if (!fh->is_file) {
                scsi_volume *p = (scsi_volume *)tmp_buf;
                p->flags = B_SCSI_PORT0_VOLUME | B_SCSI_PORT1_VOLUME;
                p->port0_volume = left;
                p->port1_volume = right;
                ioctl(fh->fd, B_SCSI_SET_VOLUME, p, sizeof(scsi_volume));
        }
}


/*
 *  Get CD audio volume (0..255 each channel)
 */

void SysCDGetVolume(void *arg, uint8 &left, uint8 &right)
{
        file_handle *fh = (file_handle *)arg;
        if (!fh)
                return;

        left = right = 0;
        if (!fh->is_file) {
                scsi_volume *p = (scsi_volume *)tmp_buf;
                p->flags = B_SCSI_PORT0_VOLUME | B_SCSI_PORT1_VOLUME;
                if (ioctl(fh->fd, B_SCSI_GET_VOLUME, p, sizeof(scsi_volume)) == 0) {
                        left = p->port0_volume;
                        right = p->port1_volume;
                }
        }
}
Revision:	1.1.1.1 (vendor branch)
Committed:	1999-10-03T14:16:25Z (25 years, 1 month ago) by cebix
Branch:	cebix
CVS Tags:	release-0_7-2, snapshot-21101999, start, snapshot-22121999, release-0_8-1, snapshot-02111999
Changes since 1.1:	+0 -0 lines
Log Message:	Imported sources
#	User	Rev	Content
1	cebix	1.1	/*
2			* sys_beos.cpp - System dependent routines, BeOS implementation
3			*
4			* Basilisk II (C) 1997-1999 Christian Bauer
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include <StorageKit.h>
22			#include <InterfaceKit.h>
23			#include <kernel/fs_info.h>
24			#include <drivers/Drivers.h>
25			#include <device/scsi.h>
26
27			#include <unistd.h>
28			#include <stdio.h>
29			#include <stdlib.h>
30			#include <string.h>
31			#include <fcntl.h>
32
33			#include "sysdeps.h"
34			#include "main.h"
35			#include "macos_util.h"
36			#include "prefs.h"
37			#include "user_strings.h"
38			#include "sys.h"
39
40			#define DEBUG 0
41			#include "debug.h"
42
43
44			// File handles are pointers to these structures
45			struct file_handle {
46			file_handle *next; // Pointer to next file handle (must be first in struct!)
47			const char *name; // File/device name (copied, for mount menu)
48			int fd; // fd of file/device
49			bool is_file; // Flag: plain file or /dev/something?
50			bool read_only; // Copy of Sys_open() flag
51			loff_t start_byte; // Size of file header (if any)
52			loff_t file_size; // Size of file data (only valid if is_file is true)
53			};
54
55			// Linked list of file handles
56			static file_handle *first_file_handle;
57
58			// Temporary buffer for transfers from/to kernel space
59			const int TMP_BUF_SIZE = 0x10000;
60			static uint8 *tmp_buf;
61
62			// For B_SCSI_PREVENT_ALLOW
63			static const int32 PREVENT = 1;
64			static const int32 ALLOW = 0;
65
66
67			/*
68			* Check if device is a mounted HFS volume, get mount name
69			*/
70
71			static bool is_drive_mounted(const char dev_name, char mount_name)
72			{
73			int32 i = 0;
74			dev_t d;
75			fs_info info;
76			while ((d = next_dev(&i)) >= 0) {
77			fs_stat_dev(d, &info);
78			if (strcmp(dev_name, info.device_name) == 0) {
79			status_t err = -1;
80			BPath mount;
81			BDirectory dir;
82			BEntry entry;
83			node_ref node;
84			node.device = info.dev;
85			node.node = info.root;
86			err = dir.SetTo(&node);
87			if (!err)
88			err = dir.GetEntry(&entry);
89			if (!err)
90			err = entry.GetPath(&mount);
91			if (!err) {
92			strcpy(mount_name, mount.Path());
93			return true;
94			}
95			}
96			}
97			return false;
98			}
99
100
101			/*
102			* Initialization
103			*/
104
105			void SysInit(void)
106			{
107			first_file_handle = NULL;
108
109			// Allocate temporary buffer
110			tmp_buf = new uint8[TMP_BUF_SIZE];
111			}
112
113
114			/*
115			* Deinitialization
116			*/
117
118			void SysExit(void)
119			{
120			delete[] tmp_buf;
121			}
122
123
124			/*
125			* Create menu of used volumes (for "mount" menu)
126			*/
127
128			void SysCreateVolumeMenu(BMenu *menu, uint32 msg)
129			{
130			for (file_handle *fh=first_file_handle; fh; fh=fh->next)
131			if (!SysIsFixedDisk(fh))
132			menu->AddItem(new BMenuItem(fh->name, new BMessage(msg)));
133			}
134
135
136			/*
137			* Mount volume given name from mount menu
138			*/
139
140			void SysMountVolume(const char *name)
141			{
142			file_handle *fh;
143			for (fh=first_file_handle; fh && strcmp(fh->name, name); fh=fh->next) ;
144			if (fh)
145			MountVolume(fh);
146			}
147
148
149			/*
150			* This gets called when no "floppy" prefs items are found
151			* It scans for available floppy drives and adds appropriate prefs items
152			*/
153
154			void SysAddFloppyPrefs(void)
155			{
156			// Only one floppy drive under BeOS
157			PrefsAddString("floppy", "/dev/disk/floppy/raw");
158			}
159
160
161			/*
162			* This gets called when no "disk" prefs items are found
163			* It scans for available HFS volumes and adds appropriate prefs items
164			*/
165
166			void SysAddDiskPrefs(void)
167			{
168			// Let BeOS scan for HFS drives
169			D(bug("Looking for Mac volumes...\n"));
170			system("mountvolume -allhfs");
171
172			// Add all HFS volumes
173			int32 i = 0;
174			dev_t d;
175			fs_info info;
176			while ((d = next_dev(&i)) >= 0) {
177			fs_stat_dev(d, &info);
178			status_t err = -1;
179			BPath mount;
180			if (!strcmp(info.fsh_name, "hfs")) {
181			BDirectory dir;
182			BEntry entry;
183			node_ref node;
184			node.device = info.dev;
185			node.node = info.root;
186			err = dir.SetTo(&node);
187			if (!err)
188			err = dir.GetEntry(&entry);
189			if (!err)
190			err = entry.GetPath(&mount);
191			}
192			if (!err)
193			err = unmount(mount.Path());
194			if (!err) {
195			char dev_name[B_FILE_NAME_LENGTH];
196			if (info.flags & B_FS_IS_READONLY) {
197			dev_name[0] = '*';
198			dev_name[1] = 0;
199			} else
200			dev_name[0] = 0;
201			strcat(dev_name, info.device_name);
202			PrefsAddString("disk", dev_name);
203			}
204			}
205			}
206
207
208			/*
209			* This gets called when no "cdrom" prefs items are found
210			* It scans for available CD-ROM drives and adds appropriate prefs items
211			*/
212
213			// Scan directory for CD-ROM drives, add them to prefs
214			static void scan_for_cdrom_drives(const char *directory)
215			{
216			// Set directory
217			BDirectory dir;
218			dir.SetTo(directory);
219			if (dir.InitCheck() != B_NO_ERROR)
220			return;
221			dir.Rewind();
222
223			// Scan each entry
224			BEntry entry;
225			while (dir.GetNextEntry(&entry) >= 0) {
226
227			// Get path and ref for entry
228			BPath path;
229			if (entry.GetPath(&path) != B_NO_ERROR)
230			continue;
231			const char *name = path.Path();
232			entry_ref e;
233			if (entry.GetRef(&e) != B_NO_ERROR)
234			continue;
235
236			// Recursively enter subdirectories (except for floppy)
237			if (entry.IsDirectory()) {
238			if (!strcmp(e.name, "floppy"))
239			continue;
240			scan_for_cdrom_drives(name);
241			} else {
242
243			D(bug(" checking '%s'\n", name));
244
245			// Ignore partitions
246			if (strcmp(e.name, "raw"))
247			continue;
248
249			// Open device
250			int fd = open(name, O_RDONLY);
251			if (fd < 0)
252			continue;
253
254			// Get geometry and device type
255			device_geometry g;
256			if (ioctl(fd, B_GET_GEOMETRY, &g, sizeof(g)) < 0) {
257			close(fd);
258			continue;
259			}
260
261			// Insert to list if it is a CD drive
262			if (g.device_type == B_CD)
263			PrefsAddString("cdrom", name);
264			close(fd);
265			}
266			}
267			}
268
269			void SysAddCDROMPrefs(void)
270			{
271			// Don't scan for drives if nocdrom option given
272			if (PrefsFindBool("nocdrom"))
273			return;
274
275			// Look for CD-ROM drives and add prefs items
276			D(bug("Looking for CD-ROM drives...\n"));
277			scan_for_cdrom_drives("/dev/disk");
278			}
279
280
281			/*
282			* Add default serial prefs (must be added, even if no ports present)
283			*/
284
285			void SysAddSerialPrefs(void)
286			{
287			system_info info;
288			get_system_info(&info);
289			switch (info.platform_type) {
290			case B_BEBOX_PLATFORM:
291			case B_AT_CLONE_PLATFORM:
292			PrefsAddString("seriala", "serial1");
293			PrefsAddString("serialb", "serial2");
294			break;
295			case B_MAC_PLATFORM:
296			PrefsAddString("seriala", "modem");
297			PrefsAddString("serialb", "printer");
298			break;
299			default:
300			PrefsAddString("seriala", "none");
301			PrefsAddString("serialb", "none");
302			break;
303			}
304			}
305
306
307			/*
308			* Open file/device, create new file handle (returns NULL on error)
309			*/
310
311			void Sys_open(const char name, bool read_only)
312			{
313			static bool published_all = false;
314			bool is_file = (strstr(name, "/dev/") != name);
315
316			D(bug("Sys_open(%s, %s)\n", name, read_only ? "read-only" : "read/write"));
317
318			// Print warning message and eventually unmount drive when this is an HFS volume mounted under BeOS (double mounting will corrupt the volume)
319			char mount_name[B_FILE_NAME_LENGTH];
320			if (!is_file && !read_only && is_drive_mounted(name, mount_name)) {
321			char str[256 + B_FILE_NAME_LENGTH];
322			sprintf(str, GetString(STR_VOLUME_IS_MOUNTED_WARN), mount_name);
323			WarningAlert(str);
324			if (unmount(mount_name) != 0) {
325			sprintf(str, GetString(STR_CANNOT_UNMOUNT_WARN), mount_name);
326			WarningAlert(str);
327			return NULL;
328			}
329			}
330
331			int fd = open(name, read_only ? O_RDONLY : O_RDWR);
332			if (fd < 0 && !published_all) {
333			// Open failed, create all device nodes and try again, but only the first time
334			system("mountvolume -publishall");
335			published_all = true;
336			fd = open(name, read_only ? O_RDONLY : O_RDWR);
337			}
338			if (fd >= 0) {
339			file_handle *fh = new file_handle;
340			fh->name = strdup(name);
341			fh->fd = fd;
342			fh->is_file = is_file;
343			fh->read_only = read_only;
344			fh->start_byte = 0;
345			if (fh->is_file) {
346			// Detect disk image file layout
347			loff_t size = lseek(fd, 0, SEEK_END);
348			uint8 data[256];
349			lseek(fd, 0, SEEK_SET);
350			read(fd, data, 256);
351			FileDiskLayout(size, data, fh->start_byte, fh->file_size);
352			}
353
354			// Enqueue file handle
355			fh->next = NULL;
356			file_handle *q = first_file_handle;
357			if (q) {
358			while (q->next)
359			q = q->next;
360			q->next = fh;
361			} else
362			first_file_handle = fh;
363			return fh;
364			} else
365			return NULL;
366			}
367
368
369			/*
370			* Close file/device, delete file handle
371			*/
372
373			void Sys_close(void *arg)
374			{
375			file_handle fh = (file_handle )arg;
376			if (!fh)
377			return;
378
379			// Free device name and close file/device
380			free((void *)fh->name);
381			close(fh->fd);
382
383			// Dequeue file handle
384			file_handle *q = first_file_handle;
385			if (q == fh) {
386			first_file_handle = NULL;
387			delete fh;
388			return;
389			}
390			while (q) {
391			if (q->next == fh) {
392			q->next = fh->next;
393			delete fh;
394			return;
395			}
396			q = q->next;
397			}
398			}
399
400
401			/*
402			* Read "length" bytes from file/device, starting at "offset", to "buffer",
403			* returns number of bytes read (or 0)
404			*/
405
406			static inline ssize_t sread(int fd, void *buf, size_t count)
407			{
408			ssize_t res;
409			while ((res = read(fd, buf, count)) == B_INTERRUPTED) ;
410			return res;
411			}
412
413			size_t Sys_read(void arg, void buffer, loff_t offset, size_t length)
414			{
415			file_handle fh = (file_handle )arg;
416			if (!fh)
417			return 0;
418
419			// D(bug("Sys_read(%08lx, %08lx, %Ld, %d)\n", fh, buffer, offset, length));
420
421			// Seek to position
422			if (lseek(fh->fd, offset + fh->start_byte, SEEK_SET) < 0)
423			return 0;
424
425			// Buffer in kernel space?
426			size_t actual = 0;
427			if ((uint32)buffer < 0x80000000) {
428
429			// Yes, transfer via buffer
430			while (length) {
431			size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
432			if (sread(fh->fd, tmp_buf, transfer_size) != transfer_size)
433			return actual;
434			memcpy(buffer, tmp_buf, transfer_size);
435			buffer = (void )((uint8 )buffer + transfer_size);
436			length -= transfer_size;
437			actual += transfer_size;
438			}
439
440			} else {
441
442			// No, transfer directly
443			actual = sread(fh->fd, buffer, length);
444			if (actual < 0)
445			actual = 0;
446			}
447			return actual;
448			}
449
450
451			/*
452			* Write "length" bytes from "buffer" to file/device, starting at "offset",
453			* returns number of bytes written (or 0)
454			*/
455
456			static inline ssize_t swrite(int fd, void *buf, size_t count)
457			{
458			ssize_t res;
459			while ((res = write(fd, buf, count)) == B_INTERRUPTED) ;
460			return res;
461			}
462
463			size_t Sys_write(void arg, void buffer, loff_t offset, size_t length)
464			{
465			file_handle fh = (file_handle )arg;
466			if (!fh)
467			return 0;
468
469			// D(bug("Sys_write(%08lx, %08lx, %Ld, %d)\n", fh, buffer, offset, length));
470
471			// Seek to position
472			if (lseek(fh->fd, offset + fh->start_byte, SEEK_SET) < 0)
473			return 0;
474
475			// Buffer in kernel space?
476			size_t actual = 0;
477			if ((uint32)buffer < 0x80000000) {
478
479			// Yes, transfer via buffer
480			while (length) {
481			size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
482			memcpy(tmp_buf, buffer, transfer_size);
483			if (swrite(fh->fd, tmp_buf, transfer_size) != transfer_size)
484			return actual;
485			buffer = (void )((uint8 )buffer + transfer_size);
486			length -= transfer_size;
487			actual += transfer_size;
488			}
489
490			} else {
491
492			// No, transfer directly
493			actual = swrite(fh->fd, buffer, length);
494			if (actual < 0)
495			actual = 0;
496			}
497			return actual;
498			}
499
500
501			/*
502			* Return size of file/device (minus header)
503			*/
504
505			loff_t SysGetFileSize(void *arg)
506			{
507			file_handle fh = (file_handle )arg;
508			if (!fh)
509			return true;
510
511			if (fh->is_file)
512			return fh->file_size;
513			else {
514			device_geometry g;
515			if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
516			return (loff_t)g.bytes_per_sector * g.sectors_per_track * g.cylinder_count * g.head_count;
517			else
518			return 0;
519			}
520			}
521
522
523			/*
524			* Eject volume (if applicable)
525			*/
526
527			void SysEject(void *arg)
528			{
529			file_handle fh = (file_handle )arg;
530			if (!fh)
531			return;
532
533			if (!fh->is_file)
534			ioctl(fh->fd, B_EJECT_DEVICE);
535			}
536
537
538			/*
539			* Format volume (if applicable)
540			*/
541
542			bool SysFormat(void *arg)
543			{
544			file_handle fh = (file_handle )arg;
545			if (!fh)
546			return false;
547
548			if (!fh->is_file)
549			return ioctl(fh->fd, B_FORMAT_DEVICE) >= 0;
550			else
551			return false;
552			}
553
554
555			/*
556			* Check if file/device is read-only (this includes the read-only flag on Sys_open())
557			*/
558
559			bool SysIsReadOnly(void *arg)
560			{
561			file_handle fh = (file_handle )arg;
562			if (!fh)
563			return true;
564
565			if (fh->is_file) {
566
567			// File, return flag given to Sys_open
568			return fh->read_only;
569
570			} else {
571
572			// Device, check write protection
573			device_geometry g;
574			if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
575			return g.read_only \| fh->read_only;
576			else
577			return fh->read_only; // Removable but not inserted
578			}
579			}
580
581
582			/*
583			* Check if the given file handle refers to a fixed or a removable disk
584			*/
585
586			bool SysIsFixedDisk(void *arg)
587			{
588			file_handle fh = (file_handle )arg;
589			if (!fh)
590			return true;
591
592			if (fh->is_file)
593			return true;
594			else {
595			device_geometry g;
596			if (ioctl(fh->fd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
597			return !g.removable;
598			else
599			return false; // Removable but not inserted
600			}
601			}
602
603
604			/*
605			* Check if a disk is inserted in the drive (always true for files)
606			*/
607
608			bool SysIsDiskInserted(void *arg)
609			{
610			file_handle fh = (file_handle )arg;
611			if (!fh)
612			return false;
613
614			if (fh->is_file)
615			return true;
616			else {
617			status_t l;
618			if (ioctl(fh->fd, B_GET_MEDIA_STATUS, &l, sizeof(l)) >= 0 && l == B_NO_ERROR)
619			return true;
620			else
621			return false;
622			}
623			}
624
625
626			/*
627			* Prevent medium removal (if applicable)
628			*/
629
630			void SysPreventRemoval(void *arg)
631			{
632			file_handle fh = (file_handle )arg;
633			if (!fh)
634			return;
635
636			if (!fh->is_file)
637			ioctl(fh->fd, B_SCSI_PREVENT_ALLOW, &PREVENT, sizeof(PREVENT));
638			}
639
640
641			/*
642			* Allow medium removal (if applicable)
643			*/
644
645			void SysAllowRemoval(void *arg)
646			{
647			file_handle fh = (file_handle )arg;
648			if (!fh)
649			return;
650
651			if (!fh->is_file)
652			ioctl(fh->fd, B_SCSI_PREVENT_ALLOW, &ALLOW, sizeof(ALLOW));
653			}
654
655
656			/*
657			* Read CD-ROM TOC (binary MSF format, 804 bytes max.)
658			*/
659
660			bool SysCDReadTOC(void arg, uint8 toc)
661			{
662			file_handle fh = (file_handle )arg;
663			if (!fh)
664			return false;
665
666			if (!fh->is_file) {
667			memset(tmp_buf, 0, 804);
668			if (ioctl(fh->fd, B_SCSI_GET_TOC, tmp_buf, 804) < 0)
669			return false;
670			memcpy(toc, tmp_buf, 804);
671			return true;
672			} else
673			return false;
674			}
675
676
677			/*
678			* Read CD-ROM position data (Sub-Q Channel, 16 bytes, see SCSI standard)
679			*/
680
681			bool SysCDGetPosition(void arg, uint8 pos)
682			{
683			file_handle fh = (file_handle )arg;
684			if (!fh)
685			return false;
686
687			if (!fh->is_file) {
688			if (ioctl(fh->fd, B_SCSI_GET_POSITION, tmp_buf, 16) < 0)
689			return false;
690			memcpy(pos, tmp_buf, 16);
691			return true;
692			} else
693			return false;
694			}
695
696
697			/*
698			* Play CD audio
699			*/
700
701			bool SysCDPlay(void *arg, uint8 start_m, uint8 start_s, uint8 start_f, uint8 end_m, uint8 end_s, uint8 end_f)
702			{
703			file_handle fh = (file_handle )arg;
704			if (!fh)
705			return false;
706
707			if (!fh->is_file) {
708			scsi_play_position p = (scsi_play_position )tmp_buf;
709			p->start_m = start_m;
710			p->start_s = start_s;
711			p->start_f = start_f;
712			p->end_m = end_m;
713			p->end_s = end_s;
714			p->end_f = end_f;
715			return ioctl(fh->fd, B_SCSI_PLAY_POSITION, p, sizeof(scsi_play_position)) == 0;
716			} else
717			return false;
718			}
719
720
721			/*
722			* Pause CD audio
723			*/
724
725			bool SysCDPause(void *arg)
726			{
727			file_handle fh = (file_handle )arg;
728			if (!fh)
729			return true;
730
731			if (!fh->is_file)
732			return ioctl(fh->fd, B_SCSI_PAUSE_AUDIO) == 0;
733			else
734			return false;
735			}
736
737
738			/*
739			* Resume paused CD audio
740			*/
741
742			bool SysCDResume(void *arg)
743			{
744			file_handle fh = (file_handle )arg;
745			if (!fh)
746			return false;
747
748			if (!fh->is_file)
749			return ioctl(fh->fd, B_SCSI_RESUME_AUDIO) == 0;
750			else
751			return false;
752			}
753
754
755			/*
756			* Stop CD audio
757			*/
758
759			bool SysCDStop(void *arg, uint8 lead_out_m, uint8 lead_out_s, uint8 lead_out_f)
760			{
761			file_handle fh = (file_handle )arg;
762			if (!fh)
763			return false;
764
765			if (!fh->is_file)
766			return ioctl(fh->fd, B_SCSI_STOP_AUDIO) == 0;
767			else
768			return false;
769			}
770
771
772			/*
773			* Perform CD audio fast-forward/fast-reverse operation starting from specified address
774			*/
775
776			bool SysCDScan(void *arg, uint8 start_m, uint8 start_s, uint8 start_f, bool reverse)
777			{
778			file_handle fh = (file_handle )arg;
779			if (!fh)
780			return false;
781
782			if (!fh->is_file) {
783			scsi_scan p = (scsi_scan )tmp_buf;
784			p->speed = 0;
785			p->direction = reverse ? -1 : 1;
786			return ioctl(fh->fd, B_SCSI_SCAN, p, sizeof(scsi_scan)) == 0;
787			} else
788			return false;
789			}
790
791
792			/*
793			* Set CD audio volume (0..255 each channel)
794			*/
795
796			void SysCDSetVolume(void *arg, uint8 left, uint8 right)
797			{
798			file_handle fh = (file_handle )arg;
799			if (!fh)
800			return;
801
802			if (!fh->is_file) {
803			scsi_volume p = (scsi_volume )tmp_buf;
804			p->flags = B_SCSI_PORT0_VOLUME \| B_SCSI_PORT1_VOLUME;
805			p->port0_volume = left;
806			p->port1_volume = right;
807			ioctl(fh->fd, B_SCSI_SET_VOLUME, p, sizeof(scsi_volume));
808			}
809			}
810
811
812			/*
813			* Get CD audio volume (0..255 each channel)
814			*/
815
816			void SysCDGetVolume(void *arg, uint8 &left, uint8 &right)
817			{
818			file_handle fh = (file_handle )arg;
819			if (!fh)
820			return;
821
822			left = right = 0;
823			if (!fh->is_file) {
824			scsi_volume p = (scsi_volume )tmp_buf;
825			p->flags = B_SCSI_PORT0_VOLUME \| B_SCSI_PORT1_VOLUME;
826			if (ioctl(fh->fd, B_SCSI_GET_VOLUME, p, sizeof(scsi_volume)) == 0) {
827			left = p->port0_volume;
828			right = p->port1_volume;
829			}
830			}
831			}