You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
430 lines
10 KiB
430 lines
10 KiB
/*
|
|
|
|
This file is part of the KFloppy program, part of the KDE project
|
|
|
|
Copyright (C) 2002 Adriaan de Groot <groot@kde.org>
|
|
Copyright (C) 2004, 2005 Nicolas GOUTTE <goutte@kde.org>
|
|
|
|
|
|
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, version 2.
|
|
|
|
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
#ifndef FORMAT_H
|
|
#define FORMAT_H
|
|
|
|
/** \file format.h
|
|
* This file defines a hierarchy of classes that
|
|
* can run a sequence of external programs (like
|
|
* fdformat, mkisofs, etc.) in sequence. Stdout
|
|
* and stderr of those programs can be captured
|
|
* and analyzed in order to provide feedback to
|
|
* the user.
|
|
*
|
|
* <ul>
|
|
* <li>KFAction: Base class, just for performing some action.
|
|
* <li>KFActionQueue: Provides sequencing of KFActions
|
|
* <li>FloppyAction: Weird name; handles running a program,
|
|
* understands FD device names. This can be
|
|
* considered the "useful" base class of
|
|
* programming actions.
|
|
* <li>FDFormat: Runs fdformat(1) under BSD or Linux.
|
|
* <li>FATFilesystem: Creates an msdos (FAT) filesystem.
|
|
* <li>Ext2Filesystem: Creates ext2 filesystems.
|
|
* <li>MinixFilesystem: Creates Minix filesystems, under Linux.
|
|
* <li>UFSFilesystem: Creates UFS filesystem, under BSD.
|
|
* </ul>
|
|
*
|
|
* \note Maybe this is overkill, since for floppies all you need is
|
|
* fdformat(1) and some create-filesystem program like newfs(1)
|
|
* or mke2fs(1). However, for Zip disks, should they ever be supported,
|
|
* this is quite useful since you need to dd, fdisk, disklabel, and
|
|
* newfs them.
|
|
*/
|
|
|
|
#include "debug.h"
|
|
#include <tqobject.h>
|
|
|
|
/**
|
|
* \brief Abstract base class of actions to be undertaken.
|
|
*
|
|
* Basically you can create a KFActionStack (See below)
|
|
* and push a bunch of actions on it, then run exec()
|
|
* on the stack and wait for the done() signal.
|
|
*/
|
|
class KFAction : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
KFAction(TQObject *parent = 0L);
|
|
virtual ~KFAction();
|
|
|
|
public slots:
|
|
/**
|
|
* Exec() should return quickly to ensire that the GUI
|
|
* thread stays alive. quit() should abort the action.
|
|
*/
|
|
virtual void exec();
|
|
/**
|
|
* Quit aborts the action. No done() signal should
|
|
* be emitted.
|
|
*/
|
|
virtual void quit();
|
|
|
|
signals:
|
|
/**
|
|
* done() should always be emitted with this as first
|
|
* parameter, to avoid sender() magic and the like.
|
|
* @p success indicates whether the action was
|
|
* successful.
|
|
*/
|
|
void done(KFAction *me,bool success);
|
|
|
|
/**
|
|
* Emit this signal to inform the user of interesting
|
|
* changes; setting msg to an empty string doesn't
|
|
* change any visible user message. @p progress
|
|
* indicates the action's progress (if that can be determined)
|
|
* and sending -1 leaves the visible indicator unchanged.
|
|
*/
|
|
void status(const TQString &msg, int progress);
|
|
|
|
/** error() displays a box. It interrupts
|
|
* the user's work and should be used with care.
|
|
*/
|
|
void error(const TQString &msg, const TQString &details);
|
|
} ;
|
|
|
|
|
|
/**
|
|
* Acts as a queue and executes the actions in the
|
|
* queue in FIFO order.
|
|
*/
|
|
class KFActionQueue : public KFAction
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
KFActionQueue(TQObject *parent = 0L);
|
|
virtual ~KFActionQueue();
|
|
|
|
/**
|
|
* Add a KFAction to the queue. When exec() is called,
|
|
* the actions are called one after the other (if each
|
|
* action is successful; if any action fails, the whole
|
|
* queue fails and the unsuccessful action is the last
|
|
* one run.) Actions become the property of the queue
|
|
* action. Note that queues can be nested.
|
|
*/
|
|
void queue(KFAction *);
|
|
|
|
virtual void exec();
|
|
|
|
protected slots:
|
|
void actionDone(KFAction *,bool);
|
|
|
|
private:
|
|
class KFActionQueue_p *d;
|
|
} ;
|
|
|
|
|
|
/*
|
|
** The remainder of the Actions are concrete ones and
|
|
** might better go off to live in another header file,
|
|
** but this is only needed if the number of supported
|
|
** formats grows enormously.
|
|
*/
|
|
|
|
/**
|
|
* Description structure for floppy devices.
|
|
* devices is a list of possible device names (yay
|
|
* /dev/ consistency) while drive,blocks denotes
|
|
* fd0 or fd1, and the size of the disk (ought to
|
|
* be 1440, 1200, 720 or 360. I've never seen a 2880
|
|
* floppy drive).
|
|
*
|
|
* Tracks is pretty bogus; see the internal code for its use.
|
|
* Similarly, flags are internal too.
|
|
*/
|
|
|
|
typedef struct { const char **devices;
|
|
int drive;
|
|
int blocks;
|
|
int tracks;
|
|
int flags; } fdinfo;
|
|
|
|
class KProcess;
|
|
|
|
/**
|
|
* Concrete action for running a single external program.
|
|
*/
|
|
|
|
class FloppyAction : public KFAction
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
FloppyAction(TQObject *parent = 0L);
|
|
|
|
/**
|
|
* Kills the running process, if one exists.
|
|
*/
|
|
virtual void quit();
|
|
|
|
/**
|
|
* ConfigureDevice() needs to be called prior to exec()
|
|
* or exec() will fail; this indicates which drive and
|
|
* density to use.
|
|
*
|
|
* \param driveno Number of drive (0 or 1)
|
|
* \param density Floppy density (in Kilobytes)
|
|
* \note This same function needs to be
|
|
* called on all subclasses in order to configure them
|
|
* for which drive to use, _along_ with their local
|
|
* configuration functions.
|
|
*/
|
|
|
|
bool configureDevice(int driveno, int density );
|
|
|
|
/**
|
|
* \brief Configure the device with a device name
|
|
*
|
|
* This is an alternate to FloppyAction::configureDevice
|
|
* for user-given devices.
|
|
*
|
|
* \note It does not work for each type of FloppyAction yet
|
|
*/
|
|
bool configureDevice( const TQString& newDeviceName );
|
|
|
|
protected:
|
|
fdinfo *deviceInfo; ///< Configuration info (Pointer into list of "/dev/..." entries)
|
|
TQString deviceName; ///< Name of the device
|
|
|
|
protected slots:
|
|
/**
|
|
* \brief Provide handling of the exit of the external program
|
|
*/
|
|
virtual void processDone(KProcess *);
|
|
/**
|
|
* \brief Provide handling of stdout
|
|
*/
|
|
virtual void processStdOut(KProcess *, char *, int);
|
|
/**
|
|
* \brief Provide handling stderr.
|
|
*
|
|
* The default implementation just sends stderr on
|
|
* to processStdOut(), so you need reimplement only
|
|
* FloppyAction::processStdOut if you choose.
|
|
*/
|
|
virtual void processStdErr(KProcess *, char *, int);
|
|
|
|
protected:
|
|
KProcess *theProcess;
|
|
TQString theProcessName; ///< human-readable
|
|
|
|
/**
|
|
* Sets up connections, calls KProcess::run().
|
|
* You need to *theProcess << program << args ; first.
|
|
*/
|
|
|
|
bool startProcess();
|
|
} ;
|
|
|
|
/**
|
|
* Concrete class that runs fdformat(1)
|
|
*/
|
|
|
|
class FDFormat : public FloppyAction
|
|
{
|
|
public:
|
|
FDFormat(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
|
|
/**
|
|
* Concrete classes can provide a runtimeCheck
|
|
* function (heck, this is static, so the name
|
|
* is up to you) that checks if the required
|
|
* applications are available. This way, the
|
|
* calling application can decide not to use
|
|
* actions whose prerequisites are absent anyway.
|
|
*/
|
|
static bool runtimeCheck();
|
|
|
|
/** @p verify instructs fdformat(1) to verify the
|
|
* medium as well.
|
|
*/
|
|
|
|
bool configure(bool verify);
|
|
|
|
virtual void processStdOut(KProcess *, char *,int);
|
|
|
|
protected:
|
|
static TQString fdformatName; ///< path to executable.
|
|
int formatTrackCount; ///< How many tracks formatted.
|
|
bool doVerify;
|
|
} ;
|
|
|
|
/**
|
|
* Zero out disk by runnind dd(1)
|
|
* \bug As dd terminates with the error "No space left on device", KFloppy aborts
|
|
*/
|
|
class DDZeroOut : public FloppyAction
|
|
{
|
|
public:
|
|
DDZeroOut(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
/**
|
|
* Concrete classes can provide a runtimeCheck
|
|
* function (heck, this is static, so the name
|
|
* is up to you) that checks if the required
|
|
* applications are available. This way, the
|
|
* calling application can decide not to use
|
|
* actions whose prerequisites are absent anyway.
|
|
*/
|
|
static bool runtimeCheck();
|
|
|
|
protected:
|
|
/**
|
|
* \brief Provide handling of the exit of the external program
|
|
*/
|
|
virtual void processDone(KProcess *);
|
|
protected:
|
|
static TQString m_ddName; ///< path to executable.
|
|
} ;
|
|
|
|
|
|
/**
|
|
* Create an msdos (FAT) filesystem on the floppy.
|
|
*/
|
|
class FATFilesystem : public FloppyAction
|
|
{
|
|
public:
|
|
FATFilesystem(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
static bool runtimeCheck();
|
|
|
|
/**
|
|
* newfs_msdos(1) doesn't support an additional verify,
|
|
* but Linux mkdosfs(1) does. Enable additional medium
|
|
* verify with @p verify. Disks can be labeled (@p label) with the
|
|
* remaining parameters (@p l).
|
|
*/
|
|
bool configure(bool verify, bool label, const TQString &l);
|
|
|
|
/// Parse output
|
|
virtual void processStdOut(KProcess*, char* b, int l);
|
|
|
|
protected:
|
|
static TQString newfs_fat;
|
|
|
|
bool doVerify,doLabel;
|
|
TQString label;
|
|
|
|
} ;
|
|
|
|
/**
|
|
* Format with Ext2
|
|
*/
|
|
class Ext2Filesystem : public FloppyAction
|
|
{
|
|
public:
|
|
Ext2Filesystem(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
static bool runtimeCheck();
|
|
|
|
/// Same args as FATFilesystem::configure
|
|
bool configure(bool verify, bool label, const TQString &l);
|
|
|
|
/// Parse output
|
|
virtual void processStdOut(KProcess*, char* b, int l);
|
|
|
|
protected:
|
|
static TQString newfs;
|
|
|
|
bool doVerify,doLabel;
|
|
TQString label;
|
|
} ;
|
|
|
|
#ifdef ANY_BSD
|
|
|
|
/**
|
|
* \brief Format with UFS
|
|
* \note BSD only
|
|
*/
|
|
class UFSFilesystem : public FloppyAction
|
|
{
|
|
public:
|
|
UFSFilesystem(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
static bool runtimeCheck();
|
|
|
|
protected:
|
|
static TQString newfs;
|
|
|
|
bool doVerify,doLabel;
|
|
TQString label;
|
|
} ;
|
|
#endif
|
|
|
|
#ifdef ANY_LINUX
|
|
/**
|
|
* \brief Format with Minix
|
|
* \note Linux only
|
|
*/
|
|
class MinixFilesystem : public FloppyAction
|
|
{
|
|
public:
|
|
MinixFilesystem(TQObject *parent = 0L);
|
|
|
|
virtual void exec();
|
|
|
|
static bool runtimeCheck();
|
|
|
|
/// Same args as FATFilesystem::configure
|
|
bool configure(bool verify, bool label, const TQString &l);
|
|
|
|
/// Parse output
|
|
virtual void processStdOut(KProcess*, char* b, int l);
|
|
protected:
|
|
static TQString newfs;
|
|
|
|
bool doVerify,doLabel;
|
|
TQString label;
|
|
} ;
|
|
#endif
|
|
|
|
/**
|
|
* Utility function that looks for executables in $PATH
|
|
* and in /sbin and /usr/sbin.
|
|
*/
|
|
|
|
TQString findExecutable(const TQString &);
|
|
|
|
#endif
|
|
|