315 lines
7.5 KiB
C++
315 lines
7.5 KiB
C++
|
|
#include <memory>
|
|
#include <new>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cerrno>
|
|
#include <cstdlib>
|
|
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
|
|
|
|
#include <Device/BlockDevice.h>
|
|
#include <Device/RawDevice.h>
|
|
|
|
|
|
#include <Common/Exception.h>
|
|
|
|
#include <Pascal/Pascal.h>
|
|
|
|
#include <File/File.h>
|
|
#include <File/MappedFile.h>
|
|
|
|
|
|
|
|
|
|
|
|
using namespace Pascal;
|
|
using namespace Device;
|
|
|
|
#define NEWFS_VERSION "0.1"
|
|
|
|
|
|
|
|
bool yes_or_no()
|
|
{
|
|
int ch, first;
|
|
(void)fflush(stderr);
|
|
|
|
first = ch = getchar();
|
|
while (ch != '\n' && ch != EOF)
|
|
ch = getchar();
|
|
return (first == 'y' || first == 'Y');
|
|
}
|
|
|
|
/*
|
|
* \d+ by block
|
|
* \d+[Kk] by kilobyte
|
|
* \d+[Mm] by megabyte
|
|
*/
|
|
unsigned parseBlocks(const char *cp)
|
|
{
|
|
unsigned long blocks = 0;
|
|
char *mod;
|
|
|
|
errno = 0;
|
|
blocks = std::strtoul(cp, &mod, 10);
|
|
if (errno) return -1;
|
|
|
|
if (mod == cp) return -1;
|
|
if (blocks > 0xffff) return -1;
|
|
|
|
if (mod)
|
|
{
|
|
switch(*mod)
|
|
{
|
|
case 0:
|
|
break;
|
|
|
|
case 'm': // 1m = 1024*1024b = 2048 blocks
|
|
case 'M':
|
|
blocks *= 2048;
|
|
break;
|
|
|
|
case 'k': // 1k = 1024b = 2 blocks
|
|
case 'K':
|
|
blocks *= 2;
|
|
break;
|
|
}
|
|
if (blocks > 0xffff) return -1;
|
|
}
|
|
|
|
|
|
return (unsigned)blocks;
|
|
}
|
|
|
|
|
|
// return the basename, without an extension.
|
|
std::string filename(const std::string& src)
|
|
{
|
|
unsigned start;
|
|
unsigned end;
|
|
|
|
|
|
if (src.empty()) return std::string("");
|
|
|
|
start = end = 0;
|
|
|
|
for(unsigned i = 0, l = src.length(); i < l; ++i)
|
|
{
|
|
char c = src[i];
|
|
if (c == '/') start = end = i + 1;
|
|
if (c == '.') end = i;
|
|
}
|
|
|
|
if (start == src.length()) return std::string("");
|
|
|
|
if (start == end) return src.substr(start);
|
|
return src.substr(start, end - start);
|
|
}
|
|
|
|
|
|
void usage()
|
|
{
|
|
std::printf("newfs_pascal %s\n", NEWFS_VERSION);
|
|
std::printf("\n");
|
|
|
|
|
|
std::printf("newfs_pascal [-v volume_name] [-s size] [-f format] file\n");
|
|
std::printf("\n");
|
|
std::printf(" -v volume_name Specify the volume name.\n"
|
|
" Default is Untitled.\n"
|
|
" -s size Specify size in blocks.\n"
|
|
" Default is 1600 blocks (800K)\n"
|
|
" -b bootfile Specify a file that contains the boot block\n"
|
|
" -f format Specify the disk image format. Valid values are:\n"
|
|
" 2img Universal Disk Image\n"
|
|
" dc42 DiskCopy 4.2 Image\n"
|
|
" davex Davex Disk Image\n"
|
|
" do DOS Order Disk Image\n"
|
|
" po ProDOS Order Disk Image (default)\n"
|
|
);
|
|
|
|
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
unsigned blocks = 1600;
|
|
std::string volumeName;
|
|
std::string fileName;
|
|
std::string bootFile;
|
|
|
|
int format = 0;
|
|
const char *fname;
|
|
int c;
|
|
|
|
|
|
while ( (c = ::getopt(argc, argv, "hf:s:v:")) != -1)
|
|
{
|
|
switch(c)
|
|
{
|
|
case 'h':
|
|
default:
|
|
usage();
|
|
return c == 'h' ? 0 : 1;
|
|
break;
|
|
|
|
case 'v':
|
|
volumeName = optarg;
|
|
// make sure it's legal.
|
|
if (!VolumeEntry::ValidName(optarg))
|
|
{
|
|
std::fprintf(stderr, "Error: `%s' is not a valid Pascal volume name.\n", optarg);
|
|
return 0x40;
|
|
}
|
|
break;
|
|
|
|
case 's':
|
|
blocks = parseBlocks(optarg);
|
|
if (blocks > 0xffff)
|
|
{
|
|
std::fprintf(stderr, "Error: `%s' is not a valid disk size.\n", optarg);
|
|
return 0x5a;
|
|
}
|
|
break;
|
|
|
|
case 'f':
|
|
format = Device::BlockDevice::ImageType(optarg);
|
|
if (format == 0)
|
|
{
|
|
std::fprintf(stderr, "Error: `%s' is not a supported disk image format.\n", optarg);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case 'b':
|
|
bootFile = optarg;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc != 1)
|
|
{
|
|
usage();
|
|
return -1;
|
|
}
|
|
|
|
|
|
fname = argv[0];
|
|
fileName = argv[0];
|
|
|
|
|
|
|
|
|
|
|
|
try
|
|
{
|
|
|
|
struct stat st;
|
|
bool rawDevice = false;
|
|
|
|
BlockDevicePointer device;
|
|
VolumeEntryPointer volume;
|
|
|
|
// Check for block device. if so, verify.
|
|
// if file exists, verify before overwrite.
|
|
std::memset(&st, 0, sizeof(st));
|
|
|
|
if (::stat(fname, &st) == 0)
|
|
{
|
|
if (S_ISBLK(st.st_mode))
|
|
{
|
|
fprintf(stderr, "`%s' is a raw device. Are you sure you want to initialize it? ", fname);
|
|
if (!yes_or_no()) return -1;
|
|
|
|
device = RawDevice::Open(fname, File::ReadWrite);
|
|
blocks = device->blocks();
|
|
rawDevice = true;
|
|
|
|
if (blocks > 0xffff)
|
|
{
|
|
std::fprintf(stderr, "Error: device is too large.\n");
|
|
return 0x5a;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
|
|
// file exists, verify we want to destroy it.
|
|
|
|
fprintf(stderr, "`%s' already exists. Are you sure you want to overwrite it? ", fname);
|
|
if (!yes_or_no()) return -1;
|
|
}
|
|
|
|
}
|
|
|
|
// generate a filename.
|
|
if (volumeName.empty())
|
|
{
|
|
if (!rawDevice)
|
|
volumeName = filename(fileName);
|
|
if (volumeName.empty() || !VolumeEntry::ValidName(volumeName.c_str()))
|
|
volumeName = "PASCAL";
|
|
}
|
|
|
|
if (!rawDevice)
|
|
device = BlockDevice::Create(fname, volumeName.c_str(), blocks, format);
|
|
|
|
if (!device.get())
|
|
{
|
|
std::fprintf(stderr, "Error: Unsupported diskimage format.\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
if (!bootFile.empty())
|
|
{
|
|
MappedFile bf(bootFile.c_str(), File::ReadOnly, std::nothrow);
|
|
|
|
if (!bf.isValid())
|
|
{
|
|
std::fprintf(stderr, "Warning: unable to open boot file `%s'.\n", bootFile.c_str());
|
|
}
|
|
else
|
|
{
|
|
size_t length = bf.length();
|
|
// either 1 or 2 blocks.
|
|
if (length == 512)
|
|
{
|
|
device->write(0, bf.address());
|
|
}
|
|
else if (length == 1024)
|
|
{
|
|
device->write(0, bf.address());
|
|
device->write(1, (uint8_t*)bf.address() + 512);
|
|
}
|
|
else
|
|
{
|
|
std::fprintf(stderr, "Warning: boot file must be 512 or 1024 bytes.\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
volume = VolumeEntry::Create(device, volumeName.c_str());
|
|
|
|
|
|
}
|
|
catch (::Exception& e)
|
|
{
|
|
std::fprintf(stderr, "%s\n", e.what());
|
|
std::fprintf(stderr, "%s\n", ::strerror(e.error()));
|
|
return -2;
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|