2162 lines
87 KiB
Raw Normal View History

2006-08-15 20:37:04 +00:00
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
#ifndef LIBBURN_H
#define LIBBURN_H
/* Needed for off_t which is the (POSIX-ly) appropriate type for
expressing a file or stream size.
XXX we should enforce 64-bitness for off_t
ts A61101 : this is usually done by the build system (if it is not broken)
2006-08-15 20:37:04 +00:00
#include <sys/types.h>
#ifndef DOXYGEN
#if defined(__cplusplus)
namespace burn { \
extern "C" {
#define BURN_END_DECLS \
} \
/** References a physical drive in the system */
struct burn_drive;
/** References a whole disc */
struct burn_disc;
/** References a single session on a disc */
struct burn_session;
/** References a single track on a disc */
struct burn_track;
/* ts A61111 */
/** References a set of write parameters */
struct burn_write_opts;
2006-08-15 20:37:04 +00:00
/** Session format for normal audio or data discs */
#define BURN_CDROM 0
/** Session format for obsolete CD-I discs */
#define BURN_CDI 0x10
/** Session format for CDROM-XA discs */
#define BURN_CDXA 0x20
#define BURN_POS_END 100
/** Mask for mode bits */
#define BURN_MODE_BITS 127
/** Track mode - mode 0 data
0 bytes of user data. it's all 0s. mode 0. get it? HAH
#define BURN_MODE0 (1 << 0)
/** Track mode - mode "raw" - all 2352 bytes supplied by app
#define BURN_MODE_RAW (1 << 1)
/** Track mode - mode 1 data
2048 bytes user data, and all the LEC money can buy
#define BURN_MODE1 (1 << 2)
/** Track mode - mode 2 data
defaults to formless, 2336 bytes of user data, unprotected
| with a data form if required.
#define BURN_MODE2 (1 << 3)
/** Track mode modifier - Form 1, | with MODE2 for reasonable results
2048 bytes of user data, 4 bytes of subheader
#define BURN_FORM1 (1 << 4)
/** Track mode modifier - Form 2, | with MODE2 for reasonable results
lots of user data. not much LEC.
#define BURN_FORM2 (1 << 5)
/** Track mode - audio
2352 bytes per sector. may be | with 4ch or preemphasis.
2006-08-24 22:33:49 +00:00
Audio data must be 44100Hz 16bit stereo with no riff or other header at
beginning. Extra header data will cause pops or clicks. Audio data should
also be in little-endian byte order. Big-endian audio data causes static.
2006-08-15 20:37:04 +00:00
#define BURN_AUDIO (1 << 6)
/** Track mode modifier - 4 channel audio. */
#define BURN_4CH (1 << 7)
/** Track mode modifier - Digital copy permitted, can be set on any track.*/
#define BURN_COPY (1 << 8)
/** Track mode modifier - 50/15uS pre-emphasis */
#define BURN_PREEMPHASIS (1 << 9)
/** Input mode modifier - subcodes present packed 16 */
#define BURN_SUBCODE_P16 (1 << 10)
/** Input mode modifier - subcodes present packed 96 */
#define BURN_SUBCODE_P96 (1 << 11)
/** Input mode modifier - subcodes present raw 96 */
#define BURN_SUBCODE_R96 (1 << 12)
/** Possible disc writing style/modes */
enum burn_write_types
/** Packet writing.
currently unsupported, (for DVD Incremental Streaming use TAO)
2006-08-15 20:37:04 +00:00
/** With CD: Track At Once recording
2s gaps between tracks, no fonky lead-ins
With sequential DVD-R[W]: Incremental Streaming
With DVD-RAM/+RW: Random Writeable (used sequentially)
With overwriteable DVD-RW: Rigid Restricted Overwrite
2006-08-15 20:37:04 +00:00
/** With CD: Session At Once
ts A70122: Currently not capable of mixing data and audio tracks.
With sequential DVD-R[W]: Disc-at-once, DAO
Single session, single track, fixed size mandatory, (-dvd-compat)
2006-08-15 20:37:04 +00:00
/** With CD: Raw disc at once recording.
all subcodes must be provided by lib or user
only raw block types are supported
2006-08-15 20:37:04 +00:00
/** In replies this indicates that not any writing will work.
As parameter for inquiries it indicates that no particular write
mode shall is specified.
Do not use for setting a write mode for burning. It won't work.
2006-08-15 20:37:04 +00:00
/** Data format to send to the drive */
enum burn_block_types
/** sync, headers, edc/ecc provided by lib/user */
/** sync, headers, edc/ecc and p/q subs provided by lib/user */
/** sync, headers, edc/ecc and packed p-w subs provided by lib/user */
/** sync, headers, edc/ecc and raw p-w subs provided by lib/user */
/** only 2048 bytes of user data provided by lib/user */
/** 2336 bytes of user data provided by lib/user */
/** 2048 bytes of user data provided by lib/user
subheader provided in write parameters
are we ever going to support this shit? I vote no.
(supposed to be supported on all drives...)
/** 2048 bytes of data + 8 byte subheader provided by lib/user
hey, this is also dumb
/** 2324 bytes of data provided by lib/user
subheader provided in write parameters
no sir, I don't like it.
/** 2332 bytes of data supplied by lib/user
8 bytes sub header provided in write parameters
this is the second least suck mode2, and is mandatory for
all drives to support.
/** SAO block sizes are based on cue sheet, so use this. */
/** Possible status' of the drive in regard to the disc in it. */
enum burn_disc_status
/** The current status is not yet known */
/** The drive holds a blank disc */
/** There is no disc at all in the drive */
/** There is an incomplete disc in the drive */
/** There is a disc with data on it in the drive */
/* ts A61007 */
/** The drive was not grabbed when the status was inquired */
/* ts A61020 */
/** The media seems not to be suitable for burning */
2006-08-15 20:37:04 +00:00
2006-09-24 20:25:54 +00:00
2006-08-15 20:37:04 +00:00
/** Possible data source return values */
enum burn_source_status
/** The source is ok */
/** The source is at end of file */
/** The source is unusable */
/** Possible busy states for a drive */
enum burn_drive_status
/** The drive is not in an operation */
/** The library is spawning the processes to handle a pending
operation (A read/write/etc is about to start but hasn't quite
yet) */
/** The drive is reading data from a disc */
/** The drive is writing data to a disc */
/** The drive is writing Lead-In */
/** The drive is writing Lead-Out */
/** The drive is erasing a disc */
/** The drive is being grabbed */
/* ts A61102 */
/** The drive gets written zeroes before the track payload data */
/** The drive is told to close a track (TAO only) */
/** The drive is told to close a session (TAO only) */
/* ts A61223 */
/** The drive is formatting media */
/* ts A70822 */
/** The drive is busy in synchronous read (if you see this then it
has been interrupted) */
/** The drive is busy in synchronous write (if you see this then it
has been interrupted) */
2006-08-15 20:37:04 +00:00
2006-08-15 20:37:04 +00:00
/** Information about a track on a disc - this is from the q sub channel of the
lead-in area of a disc. The documentation here is very terse.
See a document such as mmc3 for proper information.
CAUTION : This structure is prone to future extension !
Do not restrict your application to unsigned char with any counter like
"session", "point", "pmin", ...
Do not rely on the current size of a burn_toc_entry.
ts A70201 : DVD extension, see below
2006-08-15 20:37:04 +00:00
struct burn_toc_entry
/** Session the track is in */
unsigned char session;
/** Type of data. for this struct to be valid, it must be 1 */
unsigned char adr;
/** Type of data in the track */
unsigned char control;
/** Zero. Always. Really. */
unsigned char tno;
/** Track number or special information */
unsigned char point;
unsigned char min;
unsigned char sec;
unsigned char frame;
unsigned char zero;
/** Track start time minutes for normal tracks */
unsigned char pmin;
/** Track start time seconds for normal tracks */
unsigned char psec;
/** Track start time frames for normal tracks */
unsigned char pframe;
/* Indicates wether extension data are valid and eventually override
older elements in this structure:
bit0= DVD extension is valid
unsigned char extensions_valid;
/* ts A70201 : DVD extension.
If invalid the members are guaranteed to be 0. */
/* Tracks and session numbers are 16 bit. Here are the high bytes. */
unsigned char session_msb;
unsigned char point_msb;
/* pmin, psec, and pframe may be too small if DVD extension is valid */
int start_lba;
/* min, sec, and frame may be too small if DVD extension is valid */
int track_blocks;
2006-08-15 20:37:04 +00:00
2007-10-02 13:54:54 +00:00
/** Data source interface for tracks.
2007-10-03 11:54:42 +00:00
This allows to use arbitrary program code as provider of track input data.
2007-10-02 13:54:54 +00:00
Objects compliant to this interface are either provided by the application
2007-10-03 11:54:42 +00:00
or by API calls of libburn: burn_fd_source_new() , burn_file_source_new().
Those calls allow to use any file object as data source. Consider to feed
your data stream asynchronously into a file descriptor and to let libburn
handle the rest.
If you need to implement an own passive data producer by this interface,
then beware: it can do anything and it can spoil everything.
If implemented by the application then the functions (*read), (*get_size),
(*set_size), (*free_data) MUST be implemented and attached to the object
at creation time.
Function (*read_sub) is allowed to be NULL (or MUST be implemented).
burn_source.refcount MUST be handled properly: If not exactly as many
references are freed as have been obtained, then either memory leaks or
corrupted memory are the consequence.
All objects which are referred to by *data must be kept existent until
(*free_data) is called via burn_source_free() by the last referer.
With libburn provided burn_source objects the following rule applies:
Call burn_source_free() exactly once for every source obtained from
libburn API. You MUST NOT otherwise manipulate its refcount.
The following component description applies to application implemented
burn_source objects only. You need not to know it for API provided ones.
2007-10-02 13:54:54 +00:00
2006-08-15 20:37:04 +00:00
struct burn_source {
2007-10-02 13:54:54 +00:00
/** Reference count for the data source. MUST be 1 when a new source
2007-10-03 11:54:42 +00:00
is created and thus the first reference is handed out. Increment
it to take more references for yourself. Use burn_source_free()
to destroy your references to it. */
2007-10-02 13:54:54 +00:00
int refcount;
2006-08-15 20:37:04 +00:00
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Read data from the source. Semantics like with read(2), but MUST
either deliver the full buffer as defined by size or MUST deliver
2007-10-03 11:54:42 +00:00
EOF (return 0) or failure (return -1) at this call or at the
next following call. I.e. the only incomplete buffer may be the
last one from that source.
2007-10-03 08:41:01 +00:00
libburn will read a single sector by each call to (*read).
The size of a sector depends on BURN_MODE_*. The known range is
2048 to 2352.
2007-10-02 13:54:54 +00:00
int (*read)(struct burn_source *, unsigned char *buffer, int size);
2006-08-15 20:37:04 +00:00
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Read subchannel data from the source (NULL if lib generated)
WARNING: This is an obscure feature with CD raw write modes.
Unless you checked the libburn code for correctness in that aspect
you should not rely on raw writing with own subchannels.
ADVICE: Set this pointer to NULL.
int (*read_sub)(struct burn_source *, unsigned char *buffer, int size);
2006-08-15 20:37:04 +00:00
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Get the size of the source's data. Return 0 means unpredictable
size. If application provided (*get_size) allows return 0, then
the application MUST provide a fully functional (*set_size).
off_t (*get_size)(struct burn_source *);
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Program the reply of (*get_size) to a fixed value. It is advised
to implement this by a attribute off_t fixed_size; in *data .
The read() function does not have to take into respect this fake
setting. It is rather a note of libburn to itself. Eventually
necessary truncation or padding is done in libburn. Truncation
is usually considered a misburn. Padding is considered ok.
libburn is supposed to work even if (*get_size) ignores the
setting by (*set_size). But your application will not be able to
enforce fixed track sizes by burn_track_set_size() and possibly
even padding might be left out.
2007-01-25 18:52:50 +00:00
int (*set_size)(struct burn_source *source, off_t size);
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Clean up the source specific data. This function will be called
once by burn_source_free() when the last referer disposes the
2006-08-15 20:37:04 +00:00
void (*free_data)(struct burn_source *);
2007-10-03 11:54:42 +00:00
2006-08-15 20:37:04 +00:00
/** Next source, for when a source runs dry and padding is disabled
2007-10-02 13:54:54 +00:00
WARNING: This is an obscure feature. Set to NULL at creation and
from then on leave untouched and uninterpreted.
2006-08-15 20:37:04 +00:00
struct burn_source *next;
2007-10-03 11:54:42 +00:00
2007-10-02 13:54:54 +00:00
/** Source specific data. Here the various source classes express their
specific properties and the instance objects store their individual
2007-10-03 11:54:42 +00:00
management data. E.g. data may point to a struct like this:
2007-10-02 13:54:54 +00:00
struct app_burn_source
struct my_app *app_handle;
... other individual source parameters ...
off_t fixed_size;
2006-08-15 20:37:04 +00:00
void *data;
2007-10-03 11:54:42 +00:00
2006-08-15 20:37:04 +00:00
/** Information on a drive in the system */
struct burn_drive_info
/** Name of the vendor of the drive */
char vendor[9];
/** Name of the drive */
char product[17];
/** Revision of the drive */
char revision[5];
2007-09-08 16:09:52 +00:00
/** Invalid: Was: "Location of the drive in the filesystem." */
/** This string has no meaning any more. Once it stored the persistent
drive address. Now always use function burn_drive_d_get_adr() to
inquire a persistent address. ^^^^^^ ALWAYS ^^^^^^^^ */
2006-08-15 20:37:04 +00:00
char location[17];
/** Can the drive read DVD-RAM discs */
unsigned int read_dvdram:1;
/** Can the drive read DVD-R discs */
unsigned int read_dvdr:1;
/** Can the drive read DVD-ROM discs */
unsigned int read_dvdrom:1;
/** Can the drive read CD-R discs */
unsigned int read_cdr:1;
/** Can the drive read CD-RW discs */
unsigned int read_cdrw:1;
/** Can the drive write DVD-RAM discs */
unsigned int write_dvdram:1;
/** Can the drive write DVD-R discs */
unsigned int write_dvdr:1;
/** Can the drive write CD-R discs */
unsigned int write_cdr:1;
/** Can the drive write CD-RW discs */
unsigned int write_cdrw:1;
/** Can the drive simulate a write */
unsigned int write_simulate:1;
/** Can the drive report C2 errors */
unsigned int c2_errors:1;
/** The size of the drive's buffer (in kilobytes) */
int buffer_size;
* The supported block types in tao mode.
* They should be tested with the desired block type.
* See also burn_block_types.
int tao_block_types;
* The supported block types in sao mode.
* They should be tested with the desired block type.
* See also burn_block_types.
int sao_block_types;
* The supported block types in raw mode.
* They should be tested with the desired block type.
* See also burn_block_types.
int raw_block_types;
* The supported block types in packet mode.
* They should be tested with the desired block type.
* See also burn_block_types.
int packet_block_types;
/** The value by which this drive can be indexed when using functions
in the library. This is the value to pass to all libbburn functions
that operate on a drive. */
struct burn_drive *drive;
2006-09-24 20:25:54 +00:00
2006-08-15 20:37:04 +00:00
/** Operation progress report. All values are 0 based indices.
* */
struct burn_progress {
/** The total number of sessions */
int sessions;
/** Current session.*/
int session;
/** The total number of tracks */
int tracks;
/** Current track. */
int track;
/** The total number of indices */
int indices;
/** Curent index. */
int index;
/** The starting logical block address */
int start_sector;
/** On write: The number of sectors.
On blank: 0x10000 as upper limit for relative progress steps */
2006-08-15 20:37:04 +00:00
int sectors;
/** On write: The current sector being processed.
On blank: Relative progress steps 0 to 0x10000 */
2006-08-15 20:37:04 +00:00
int sector;
/* ts A61023 */
/** The capacity of the drive buffer */
unsigned buffer_capacity;
/** The free space in the drive buffer (might be slightly outdated) */
unsigned buffer_available;
/* ts A61119 */
/** The number of bytes sent to the drive buffer */
off_t buffered_bytes;
/** The minimum number of bytes stored in buffer during write.
(Caution: Before surely one buffer size of bytes was processed,
this value is 0xffffffff.)
unsigned buffer_min_fill;
2006-08-15 20:37:04 +00:00
/* ts A61226 */
/** Description of a speed capability as reported by the drive in conjunction
with eventually loaded media. There can be more than one such object per
drive. So they are chained via .next and .prev , where NULL marks the end
of the chain. This list is set up by burn_drive_scan() and gets updated
by burn_drive_grab().
A copy may be obtained by burn_drive_get_speedlist() and disposed by
For technical background info see SCSI specs MMC and SPC:
mode page 2Ah (from SPC 5Ah MODE SENSE) , mmc3r10g.pdf , 6.3.11 Table 364
ACh GET PERFORMANCE, Type 03h , mmc5r03c.pdf , Table 312
struct burn_speed_descriptor {
/** Where this info comes from :
0 = misc , 1 = mode page 2Ah , 2 = ACh GET PERFORMANCE */
int source;
/** The media type that was current at the time of report
-2 = state unknown, -1 = no media was loaded , else see
burn_disc_get_profile() */
int profile_loaded;
char profile_name[80];
/** The attributed capacity of appropriate media in logical block units
i.e. 2352 raw bytes or 2048 data bytes. -1 = capacity unknown. */
int end_lba;
/** Speed is given in 1000 bytes/s , 0 = invalid. The numbers
are supposed to be usable with burn_drive_set_speed() */
int write_speed;
int read_speed;
/** Expert info from ACh GET PERFORMANCE and/or mode page 2Ah.
Expect values other than 0 or 1 to get a meaning in future.*/
/* Rotational control: 0 = CLV/default , 1 = CAV */
int wrc;
/* 1 = drive promises reported performance over full media */
int exact;
/* 1 = suitable for mixture of read and write */
int mrw;
/** List chaining. Use .next until NULL to iterate over the list */
struct burn_speed_descriptor *prev;
struct burn_speed_descriptor *next;
2006-08-15 20:37:04 +00:00
/** Initialize the library.
This must be called before using any other functions in the library. It
may be called more than once with no effect.
It is possible to 'restart' the library by shutting it down and
re-initializing it. This is necessary if you follow the older and
more general way of accessing a drive via burn_drive_scan() and
burn_drive_grab(). See burn_drive_scan_and_grab() with its strong
urges and its explanations.
2006-08-15 20:37:04 +00:00
@return Nonzero if the library was able to initialize; zero if
initialization failed.
int burn_initialize(void);
/** Shutdown the library.
This should be called before exiting your application. Make sure that all
drives you have grabbed are released <i>before</i> calling this.
void burn_finish(void);
/* ts A61002 */
/** Abort any running drive operation and finally call burn_finish().
You MUST calm down the busy drive if an aborting event occurs during a
burn run. For that you may call this function either from your own signal
handling code or indirectly by activating the builtin signal handling:
burn_set_signal_handling("my_app_name : ", NULL, 0);
Else you may eventually call burn_drive_cancel() on the active drive and
wait for it to assume state BURN_DRIVE_IDLE.
@param patience Maximum number of seconds to wait for drives to finish
@param pacifier_func If not NULL: a function to produce appeasing messages.
See burn_abort_pacifier() for an example.
2006-12-11 21:51:00 +00:00
@param handle Opaque handle to be used with pacifier_func
@return 1 ok, all went well
0 had to leave a drive in unclean state
<0 severe error, do no use libburn again
int burn_abort(int patience,
int (*pacifier_func)(void *handle, int patience, int elapsed),
void *handle);
/** A pacifier function suitable for burn_abort.
@param handle If not NULL, a pointer to a text suitable for printf("%s")
@param patience Maximum number of seconds to wait
@param elapsed Elapsed number of seconds
int burn_abort_pacifier(void *handle, int patience, int elapsed);
/** ts A61006 : This is for development only. Not suitable for applications.
Set the verbosity level of the library. The default value is 0, which means
2006-08-15 20:37:04 +00:00
that nothing is output on stderr. The more you increase this, the more
debug output should be displayed on stderr for you.
@param level The verbosity level desired. 0 for nothing, higher positive
values for more information output.
void burn_set_verbosity(int level);
/* ts A60813 */
/** Set parameters for behavior on opening device files. To be called early
after burn_initialize() and before any bus scan. But not mandatory at all.
Parameter value 1 enables a feature, 0 disables.
Default is (1,0,0). Have a good reason before you change it.
@param exclusive Linux only:
0 = no attempt to make drive access exclusive.
1 = Try to open only devices which are not marked as busy
and try to mark them busy if opened sucessfully. (O_EXCL)
There are kernels which simply don't care about O_EXCL.
Some have it off, some have it on, some are switchable.
2 = in case of a SCSI device, also try to open exclusively
the matching /dev/sr, /dev/scd and /dev/st .
One may select a device SCSI file family by adding
0 = default family
4 = /dev/sr%d
8 = /dev/scd%d
16 = /dev/sg%d
Do not use other values !
Add 32 to demand an exclusive lock by fcntl(,F_SETLK,)
after open() has succeeded.
@param blocking Try to wait for drives which do not open immediately but
also do not return an error as well. (O_NONBLOCK)
This might stall indefinitely with /dev/hdX hard disks.
@param abort_on_busy Unconditionally abort process when a non blocking
exclusive opening attempt indicates a busy drive.
Use this only after thorough tests with your app.
void burn_preset_device_open(int exclusive, int blocking, int abort_on_busy);
/* ts A70223 */
/** Allows the use of media types which are implemented in libburn but not yet
tested. The list of those untested profiles is subject to change.
Currently it contains: 0x15 "DVD-R/DL sequential recording",
0x2b "DVD+R/DL"
If you really test such media, then please report the outcome on
If ever then this call should be done soon after burn_initialize() before
any drive scanning.
@param yes 1=allow all implemented profiles, 0=only tested media (default)
void burn_allow_untested_profiles(int yes);
/* ts A60823 */
/** Aquire a drive with known persistent address.
This is the sysadmin friendly way to open one drive and to leave all
others untouched. It bundles the following API calls to form a
non-obtrusive way to use libburn:
burn_drive_add_whitelist() , burn_drive_scan() , burn_drive_grab()
You are *strongly urged* to use this call whenever you know the drive
address in advance.
2007-09-08 16:09:52 +00:00
If not, then you have to use directly above calls. In that case, you are
2006-09-11 17:49:42 +00:00
*strongly urged* to drop any unintended drive which will be exclusively
occupied and not closed by burn_drive_scan().
This can be done by shutting down the library including a call to
burn_finish(). You may later start a new libburn session and should then
use the function described here with an address obtained after
2007-09-08 16:09:52 +00:00
burn_drive_scan() via burn_drive_d_get_adr(drive_infos[driveno].drive,adr).
2006-09-11 17:49:42 +00:00
Another way is to drop the unwanted drives by burn_drive_info_forget().
2007-09-08 16:09:52 +00:00
Operating on multiple drives:
2007-09-08 16:09:52 +00:00
Different than with burn_drive_scan() it is allowed to call
burn_drive_scan_and_grab() without giving up any other scanned drives. So
this call can be used to get a collection of more than one aquired drives.
The attempt to aquire the same drive twice will fail, though.
2007-09-08 16:09:52 +00:00
burn_drive_scan_and_grab() is able to aquire virtual drives which will
accept options much like a MMC burner drive. Many of those options will not
cause any effect, though. The address of a pseudo-drive begins with
prefix "stdio:" followed by a path.
Examples: "stdio:/tmp/pseudo_drive" , "stdio:/dev/null" , "stdio:-"
If the path is empty, the result is a null-drive = drive role 0.
It pretends to have loaded no media and supports no reading or writing.
If the path leads to an existing regular file, or to a not yet existing
file, or to an existing block device, then the result is a random access
stdio-drive capable of reading and writing = drive role 2.
If the path leads to an existing file of any type other than directory,
then the result is a sequential write-only stdio-drive = drive role 3.
The special address form "stdio:/dev/fd/<number>" is interpreted literally
as reference to open file descriptor <number>. This address form coincides
with real files on some systems, but it is in fact hardcoded in libburn.
Special address "stdio:-" means stdout = "stdio:/dev/fd/1".
The role of such a drive is determined by the file type obtained via
Roles 2 and 3 perform all their eventual data transfer activities on a file
2007-09-08 16:09:52 +00:00
via standard i/o functions open(2), lseek(2), read(2), write(2), close(2).
The media profile is reported as 0xffff. Write space information from those
media is not necessarily realistic.
The capabilities of role 2 resemble DVD-RAM but it can simulate writing.
2007-09-08 16:09:52 +00:00
If the path does not exist in the filesystem yet, it is attempted to create
it as a regular file as soon as write operations are started.
The capabilities of role 3 resemble a blank DVD-R.
2007-09-08 16:09:52 +00:00
One may distinguish pseudo-drives from MMC drives by call
@param drive_infos On success returns a one element array with the drive
(cdrom/burner). Thus use with driveno 0 only. On failure
the array has no valid elements at all.
The returned array should be freed via burn_drive_info_free()
when it is no longer needed, and before calling a scan
function again.
This is a result from call burn_drive_scan(). See there.
Use with driveno 0 only.
2007-09-08 16:09:52 +00:00
@param adr The persistent address of the desired drive. Either once
obtained by burn_drive_d_get_adr() or composed skillfully by
application resp. its user. E.g. "/dev/sr0".
Consider to preprocess it by burn_drive_convert_fs_adr().
@param load Nonzero to make the drive attempt to load a disc (close its
tray door, etc).
@return 1 = success , 0 = drive not found , -1 = other error
int burn_drive_scan_and_grab(struct burn_drive_info *drive_infos[],
char* adr, int load);
/* ts A51221 */
/** Maximum number of particularly permissible drive addresses */
/** Add a device to the list of permissible drives. As soon as some entry is in
the whitelist all non-listed drives are banned from scanning.
@return 1 success, <=0 failure
int burn_drive_add_whitelist(char *device_address);
2006-09-11 17:49:42 +00:00
/** Remove all drives from whitelist. This enables all possible drives. */
void burn_drive_clear_whitelist(void);
2006-09-11 17:49:42 +00:00
/** Scan for drives. This function MUST be called until it returns nonzero.
In case of re-scanning:
All pointers to struct burn_drive and all struct burn_drive_info arrays
are invalidated by using this function. Do NOT store drive pointers across
calls to this function !
To avoid invalid pointers one MUST free all burn_drive_info arrays
by burn_drive_info_free() before calling burn_drive_scan() a second time.
If there are drives left, then burn_drive_scan() will refuse to work.
After this call all drives depicted by the returned array are subject
to eventual (O_EXCL) locking. See burn_preset_device_open(). This state
ends either with burn_drive_info_forget() or with burn_drive_release().
It is unfriendly to other processes on the system to hold drives locked
which one does not definitely plan to use soon.
@param drive_infos Returns an array of drive info items (cdroms/burners).
The returned array must be freed by burn_drive_info_free()
before burn_finish(), and also before calling this function
burn_drive_scan() again.
@param n_drives Returns the number of drive items in drive_infos.
@return 0 while scanning is not complete
>0 when it is finished sucessfully,
<0 when finished but failed.
2006-08-15 20:37:04 +00:00
int burn_drive_scan(struct burn_drive_info *drive_infos[],
2006-08-15 20:37:04 +00:00
unsigned int *n_drives);
/* ts A60904 : ticket 62, contribution by elmom */
2006-09-11 17:49:42 +00:00
/** Release memory about a single drive and any exclusive lock on it.
Become unable to inquire or grab it. Expect FATAL consequences if you try.
@param drive_info pointer to a single element out of the array
obtained from burn_drive_scan() : &(drive_infos[driveno])
@param force controls degree of permissible drive usage at the moment this
function is called, and the amount of automatically provided
drive shutdown :
0= drive must be ungrabbed and BURN_DRIVE_IDLE
1= try to release drive resp. accept BURN_DRIVE_GRABBING
Use these two only. Further values are to be defined.
@return 1 on success, 2 if drive was already forgotten,
0 if not permissible, <0 on other failures,
int burn_drive_info_forget(struct burn_drive_info *drive_info, int force);
/** When no longer needed, free a whole burn_drive_info array which was
returned by burn_drive_scan().
For freeing single drive array elements use burn_drive_info_forget().
2006-08-15 20:37:04 +00:00
void burn_drive_info_free(struct burn_drive_info drive_infos[]);
2006-08-15 20:37:04 +00:00
/* ts A60823 */
/** Maximum length+1 to expect with a persistent drive address string */
#define BURN_DRIVE_ADR_LEN 1024
/** Inquire the persistent address of the given drive.
@param drive The drive to inquire.
@param adr An application provided array of at least BURN_DRIVE_ADR_LEN
characters size. The persistent address gets copied to it.
@return >0 success , <=0 error (due to libburn internal problem)
int burn_drive_d_get_adr(struct burn_drive *drive, char adr[]);
/** Inquire the persistent address of a drive via a given drive_info object.
(Note: This is a legacy call.)
2007-09-08 16:09:52 +00:00
@param drive_info The drive to inquire.Usually some &(drive_infos[driveno])
@param adr An application provided array of at least BURN_DRIVE_ADR_LEN
characters size. The persistent address gets copied to it.
@return >0 success , <=0 error (due to libburn internal problem)
2006-09-11 17:49:42 +00:00
int burn_drive_get_adr(struct burn_drive_info *drive_info, char adr[]);
/* ts A60922 ticket 33 */
/** Evaluate wether the given address would be a possible persistent drive
address of libburn.
@return 1 means yes, 0 means no
int burn_drive_is_enumerable_adr(char *adr);
/* ts A60922 ticket 33 */
/** Try to convert a given existing filesystem address into a persistent drive
address. This succeeds with symbolic links or if a hint about the drive's
system address can be read from the filesystem object and a matching drive
is found.
@param path The address of an existing file system object
@param adr An application provided array of at least BURN_DRIVE_ADR_LEN
characters size. The persistent address gets copied to it.
@return 1 = success , 0 = failure , -1 = severe error
int burn_drive_convert_fs_adr(char *path, char adr[]);
/* ts A60923 */
/** Try to convert a given SCSI address of bus,host,channel,target,lun into
a persistent drive address. If a SCSI address component parameter is < 0
then it is not decisive and the first enumerated address which matches
the >= 0 parameters is taken as result.
Note: bus and (host,channel) are supposed to be redundant.
2006-12-11 21:51:00 +00:00
@param bus_no "Bus Number" (something like a virtual controller)
@param host_no "Host Number" (something like half a virtual controller)
@param channel_no "Channel Number" (other half of "Host Number")
@param target_no "Target Number" or "SCSI Id" (a device)
@param l