List of assert() calls in libburn. 6 Oct 2006.

Format:

------------------------------------------------------------------------------

   Number) grep'ed line
   (++ before number means: is fully done, + means is done so far )
function():
Description of abort condition.

Possible callers and their relation to the abort condition.

: Error Evaluation
=> Consequences

Eventual implementation timestamp

------------------------------------------------------------------------------

++ 1) libburn/async.c:	assert(a != NULL);	/* wasn't found.. this should not be possible */
static remove_worker():
A thread describing structure (struct w_list) could not be found in
order to be released.

Called by API burn_drive_scan()
Called by static erase_worker_func() , thread under API burn_disc_erase()
Called by static write_disc_worker_func(), thread under API burn_disc_write()
All three want to clean up after they are done.

: Severe Libburn Error
=> issue LIBDAX_MSGS_SEV_WARNING

ts A61006

------------------------------------------------------------------------------

++ 2) libburn/async.c:	assert(!(workers && workers->drive));
API burn_drive_scan():
Before spawning a thread, the function refuses work because another
drive activity is going on.

: Severe Application Error
=> return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_SORRY

ts A61006

------------------------------------------------------------------------------

+  3) libburn/async.c:		assert(workers == NULL);
API burn_drive_scan():
After thread is done and remover_worker() succeeded, there is still a
worker registered. Shall probably detect roguely appeared burn or
erase runs. (I consider to install a mutex shielded function for that.)

: Severe Libburn Error
=> Same as 1)

ts A61006

------------------------------------------------------------------------------

++ 4) libburn/async.c:	assert(drive);
      libburn/async.c:	assert(!SCAN_GOING());
      libburn/async.c:	assert(!find_worker(drive));
API burn_disc_erase():
Wants to see a drive (assumes NULL == 0), wants to see no scan and
wants to see no other worker on that drive. I.e. this would tolerate
a parallel activity on another drive.

: Severe Application Error
=> (no return value), issue LIBDAX_MSGS_SEV_SORRY

ts A61006

------------------------------------------------------------------------------

++ 5) libburn/async.c:	assert(!SCAN_GOING());
      libburn/async.c:	assert(!find_worker(opts->drive));
API burn_disc_write():
Same as 4)

: Severe Application Error
=> Same as 4)

ts A61006

---------------------------------------------------------------------

++ 6) libburn/drive.c:	assert(d->busy == BURN_DRIVE_IDLE);
API burn_drive_release():
A drive is not idle on release.

: Severe Application Error
=> Same as 4)

ts A61007

------------------------------------------------------------------------------

++ 7) libburn/drive.c:			assert(d->released);
burn_wait_all()
A drive is found grabbed.

Called by burn_drive_scan_sync(), thread under API burn_drive_scan()
Called by API burn_finish

: Severe Application Error
=> rename and redefine burn_wait_all() : now burn_drives_are_clear()
=> change all use of burn_wait_all()
=> Move tests up to burn_drive_scan()
=> There: return -1; issue LIBDAX_MSGS_SEV_SORRY

ts A61007

------------------------------------------------------------------------------

++ 8) libburn/drive.c:	assert(!d->released);
API burn_disc_get_status()
Attempt to read status of non-grabbed drive.

: Severe Application Error
=> extend enum burn_disc_status by BURN_DISC_UNGRABBED
=> return BURN_DISC_UNGRABBED, issue LIBDAX_MSGS_SEV_SORRY

ts A61007

------------------------------------------------------------------------------

++ 9) libburn/drive.c:	assert(			/* (write_type >= BURN_WRITE_PACKET) && */
burn_drive_get_block_types():
Will not work on BURN_WRITE below BURN_WRITE_RAW.

Called by -nobody- ?

: Severe Application Error
=> inactivate unused function

ts A61007

------------------------------------------------------------------------------

++ 10) libburn/drive.c:	assert(d->idata);
       libburn/drive.c:	assert(d->mdata);
static drive_getcaps():
sg.c:enumerate_common() did not succeed in creating a proper struct burn_drive
Called by burn_drive_scan_sync()

: Severe System Error
=> This could possibly really stay an abort() because the reason is
   a plain failure of the system's memory management.
=> Detect this failure already in enumerate_common(),
   issue LIBDAX_MSGS_SEV_FATAL, return

ts A61007

------------------------------------------------------------------------------

++ 11) libburn/drive.c:	assert(burn_running);
burn_drive_scan_sync():
The library was not initialized.

Called as thread by API burn_drive_scan()

: Severe Application Error
=> Move this test up to burn_drive_scan()
=> There: return -1; redefine @return in API , issue LIBDAX_MSGS_SEV_FATAL

ts A61007

------------------------------------------------------------------------------

++ 12) libburn/drive.c:			assert(d->released == 1);
burn_drive_scan_sync():
Inactivated

: (Severe Application Error)
=> throw out inactivated code

ts A61007

------------------------------------------------------------------------------

++ 13) libburn/drive.c:	assert(strlen(d->devname) < BURN_DRIVE_ADR_LEN);
burn_drive_raw_get_adr():
An enumerated device address is longer than the API's maximum length

Called by API burn_drive_get_adr()
Called by API burn_drive_obtain_scsi_adr()

: Severe Libburn Error
=> return -1; in all three functions, enhance burn_drive_get_adr @return docs
=> issue LIBDAX_MSGS_SEV_SORRY

ts A61007

------------------------------------------------------------------------------

++ 14) libburn/drive.c:	assert(drive_info->drive!=NULL);
API burn_drive_get_adr():
Drive info has no drive attached.

: Severe Libburn Error (unlikely, will eventually SIGSEGV on NULL)
=> delete assert

ts A61007

------------------------------------------------------------------------------

++ 15) libburn/init.c:	assert(burn_running);
API burn_finish():
The library is not initialized

: Severe Application Error
=> return (assume no msg system)

ts A61007

------------------------------------------------------------------------------

++ 16) libburn/init.c:	assert(burn_running);
API burn_preset_device_open():
The library is not initialized

: Severe Application Error
=> return (assume no msg system)

ts A61007

------------------------------------------------------------------------------

++ 17) libburn/mmc.c:	assert(o->drive == d);
mmc_close_disc():
alias: struct burn_drive.close_disc()
Parameters struct burn_drive and struct burn_write_opts do not match

Called by -nobody- ?

( => Disable unused function ? )
=> removed redundant parameter struct burn_drive

ts A61009

------------------------------------------------------------------------------

++ 18) libburn/mmc.c:	assert(o->drive == d);
mmc_close_session():
Same as 17)
alias: struct burn_drive.close_session()

Called by -nobody- ?

( => Disable unused function ? )
=> removed redundant parameter struct burn_drive

ts A61009

------------------------------------------------------------------------------

++ 19) libburn/mmc.c:	assert(buf->bytes >= buf->sectors);	/* can be == at 0... */
mmc_write_12():
- Unclear what .bytes and .sectors mean in struct buffer -

Called by -nobody- ?

=> problems with filling the write buffer have to be handled by callers
=> delete assert 

ts A61009

------------------------------------------------------------------------------

++ 20) libburn/mmc.c:	assert(buf->bytes >= buf->sectors);	/* can be == at 0... */
mmc_write():
- Unclear what .bytes and .sectors mean in struct buffer -

libburn/mmc.c:          c.page->sectors = errorblock - start + 1;
mmc_read_sectors() by toc_find_modes() by mmc_read_toc() alias drive.read_toc()
by burn_drive_grab()
This seems to be unrelated to mmc_write().

libburn/sector.c:       out->sectors++;
get_sector()
Seems to hand out sector start pointer in opts->drive->buffer
and to count reservation transactions as well as reserved bytes.
Ensures out->bytes >= out->sectors


libburn/mmc.c:  c.page->bytes = s->count * 8;
mmc_send_cue_sheet()
Does not use mmc_write() but directly (sg_)issue_command()

libburn/sector.c:       out->bytes += seclen;
get_sector()
See above
Ensures out->bytes >= out->sectors

libburn/spc.c:  c.page->bytes = 8 + 2 + d->mdata->retry_page_length;
spc_select_error_params()
Does not use mmc_write() but directly (sg_)issue_command()

libburn/spc.c:  c.page->bytes = 8 + 2 + d->mdata->write_page_length;
spc_select_error_params()
Does not use mmc_write() but directly (sg_)issue_command()

libburn/spc.c:          c.page->bytes = 8 + 2 + 0x32;
spc_probe_write_modes()
Does not use mmc_write() but directly (sg_)issue_command()

alias struct burn_drive.write()
Called by static get_sector, by many
Called by burn_write_flush
Called by burn_write_track

=> problems with filling the write buffer have to be handled by callers
=> delete assert 

ts A61009

------------------------------------------------------------------------------

++ 21) libburn/mmc.c:	assert(((dlen - 2) % 11) == 0);
mmc_read_toc():
- Is defunct -

=> :)

ts A61009

------------------------------------------------------------------------------

++ 22) libburn/mmc.c:	assert(len >= 0);
mmc_read_sectors():
Catches a bad parameter

alias: struct burn_drive.read_sectors()
Called by API burn_disc_read() , - is defunct -, one could catch the problem
Called by toc_find_modes(), problem cannot occur: mem.sectors = 1;

: Severe Libburn Error
(=> in burn_disc_read() check page.sectors before d->read_sectors() )
=> :)

ts A61009

------------------------------------------------------------------------------

++ 23) libburn/mmc.c:	assert(d->busy);
mmc_read_sectors():
Catches use of a drive that is not marked as busy

alias: struct burn_drive.read_sectors()
Called by API burn_disc_read() , - is defunct -, busy = BURN_DRIVE_READING;
Called by toc_find_modes(), does the same assert. To be solved there.

: Severe Libburn Error
=> :)

ts A61009

------------------------------------------------------------------------------

++ 24) libburn/options.c:	assert(0);
API burn_write_opts_set_write_type():
Detects unsuitable enum burn_write_types write_type and int block_type.
API promises return 0 on failure

: Severe Application Error
=> issue LIBDAX_MSGS_SEV_SORRY
=> should also detect problem of 26) : wrong write_type,block_type combination
   by calling sector_get_outmode() and checking for -1
=> should also detect problem of 41) : unknown block_type
   by spc_block_type() and checking for -1
=> delete assert(0)

ts A61007

------------------------------------------------------------------------------

++ 25) libburn/read.c:	assert((o->version & 0xfffff000) == (OPTIONS_VERSION & 0xfffff000));
       libburn/read.c:	assert(!d->busy);
       libburn/read.c:	assert(d->toc->valid);
       libburn/read.c:	assert(o->datafd != -1);
API burn_disc_read():
- ? -

burn_disc_read() is defunct
OPTIONS_VERSION does not occur outside this line

( => one would return )
( 22) => catch page.sectors<0 before d->read_sectors() )
( 37) => catch ! d->mdata->valid )
=> :)

ts A61007

------------------------------------------------------------------------------

++ 26) libburn/sector.c:	assert(0);		/* return BURN_MODE_UNIMPLEMENTED :) */
static get_outmode():
burn_write_opts is wrongly programmed with .write_type and .block_type

: Severe Application Error
=> This gets handled by burn_write_opts_set_write_type()
   ts A61007 by new semi-public sector_get_outmode()
=> delete assert()

ts A61007

------------------------------------------------------------------------------

++ 27) libburn/sector.c:	assert(outlen >= inlen);
       libburn/sector.c:	assert(outmode & BURN_MODE_RAW);
       libburn/sector.c:	assert(offset != -1);
static convert_data():
Several unacceptable settings within struct burn_write_opts

Called by sector_toc() sector_pregap() sector_postgap() sector_lout()
          sector_data() 

: Severe Application Error
=> change return type of convert_data()
=> all callers interpret return value and eventually return failure

ts A61007

------------------------------------------------------------------------------

++ 28) libburn/sector.c:	assert(0);
static char_to_isrc():
Called by subcode_user() with data set by API burn_track_set_isrc()
Some character conversion fails on wrong input

: Severe Application Error
=> burn_track_set_isrc() has to make sure that only good data are set
=> char_to_isrc() returns 0 as default
=> delete assert()

ts A61008

------------------------------------------------------------------------------

++ 29) libburn/sector.c:	assert(qmode == 1 || qmode == 2 || qmode == 3);
subcode_user():
- can not happen -

: Unknown reason of assert()
=> remove assert()

ts A61010

------------------------------------------------------------------------------

++ 30) libburn/sector.c:	assert(modebyte == 1);
sector_headers():
Does only accept modes BURN_AUDIO, BURN_MODE1 or write_type BURN_WRITE_SAO

Called by sector_toc() sector_pregap() sector_postgap() sector_lout()
          sector_data()

: Severe Libburn Error
=> new functions sector_headers_is_ok(), burn_disc_write_is_ok() 
   help to catch problem in API burn_disc_write()
=> issue LIBDAX_MSGS_SEV_FATAL

ts A61009

------------------------------------------------------------------------------

++ 31) libburn/sector.c:		assert(0);
process_q()
- defunct -

=> :)

ts A61009

------------------------------------------------------------------------------

++ 32) libburn/sg.c:		assert("drive busy" == "non fatal");
sg_handle_busy_device():
Intentional abort preset by the app

=> change to abort()

ts A61007

------------------------------------------------------------------------------

++ 33) libburn/sg.c:	assert(fd != -1337);
sg_grab():
The drive device file could not be opened

:Severe External Problem
=> obsolete by normal drive open failure handling

ts A61007

------------------------------------------------------------------------------

++ 34) libburn/sg.c:		assert(!c->page);
sg_issue_command():
An SCSI command of direction NO_TRANSFER may not have a .page != NULL.

Since it is about exposing a libburn detail towards the sg driver, i believe
it is sufficient to just not use it.

: Libburn Error
=> enhance internal logics of sg_issue_command()

ts A61007

------------------------------------------------------------------------------

++ 35) libburn/sg.c:			assert(c->page->bytes > 0);
sg_issue_command():
An SCSI command of direction TO_DRIVE wants to transfer 0 bytes.

: Severe Libburn Error
=> set command.error = 1 and return 0

ts A61010

------------------------------------------------------------------------------

++ 36) libburn/sg.c:		assert(err != -1);
sg_issue_command():
The transfer of the command via ioctl() failed 

: Severe Transport Level Problem
=> close drive fd, set idle and released
=> set command.error = 1 and return -1

ts A61010

------------------------------------------------------------------------------

++ 37) libburn/spc.c:	assert(d->mdata->valid);
spc_select_error_params():
Drive was not properly programmed

alias struct burn_drive.send_parameters()
Called by burn_disc_read, - defunct -

: Severe Application Error
=> moved up as mangled assert to burn_disc_read()

ts A61007

------------------------------------------------------------------------------

++ 38) libburn/spc.c:	assert(d->mdata->cdr_write || d->mdata->cdrw_write ||
spc_sense_write_params():
Drive does not offer write of any known media type

alias struct burn_drive.read_disc_info()
Called by API burn_drive_grab (assert test made there in soft)

: Severe Command Level Problem
=> remove assert()

ts A61007

------------------------------------------------------------------------------

++ 39) libburn/spc.c:	assert(o->drive == d);
spc_select_write_params():
Drive does not match struct burn_write_opts

alias struct burn_drive.send_write_parameters()
Called by mmc_close_disc() (-defunct- ?), mmc_close_session() (-defunct- ?),
          burn_write_track() (d = o->drive;), 
          burn_disc_write_sync() d = (o->drive;)

: Severe Libburn Error
=> remove assert()

ts A61007

------------------------------------------------------------------------------

++ 40) libburn/spc.c:	assert(d->mdata->valid);
spc_select_write_params():
Drive was not properly programmed

Called by (see 39)
  burn_write_track() by burn_write_session() by burn_disc_write_sync()
  burn_disc_write_sync() indirectly by API burn_disc_write()

: Severe Libburn Error
=> caught in burn_disc_write() now

ts A61007

------------------------------------------------------------------------------

++ 41) libburn/spc.c:	assert(0);
spc_block_type():
Unknown value with enum burn_block_types

Called by spc_select_write_params, uses burn_write_opts.block_type,
       set by API burn_write_opts_set_write_type()

: Severe Application Error
=> catch in API burn_write_opts_set_write_type
   by calling spc_block_type()
=> delete assert

ts A61007

------------------------------------------------------------------------------

++ 42) libburn/structure.c:	assert(!(pos > BURN_POS_END));\
macro RESIZE
An illegal list index is given by the app.

( TO->NEW##s obviusly means to append "s" to cpp result of TO->NEW )
Used by API burn_session_add_track() and API burn_disc_add_session()

: Severe Application Error
=> replace assert by if-and-return-0

ts A61008

------------------------------------------------------------------------------

++ 43) libburn/structure.c:	assert(s->track != NULL);
API burn_session_remove_track()
An application supplied pointer is NULL

: Severe Application Error
=> replace by if-and-return-0

ts A61008

------------------------------------------------------------------------------

++ 44) libburn/structure.c:		assert((country[i] >= '0' || country[i] < '9') &&
        libburn/structure.c:		assert((owner[i] >= '0' || owner[i] < '9') &&
        libburn/structure.c:	assert(year <= 99);
        libburn/structure.c:	assert(serial <= 99999);
API burn_track_set_isrc():
Illegal texts supplied by application.
The logical expression is always true !

: Severe Application Error
=> issue LIBDAX_MSGS_SEV_SORRY and return
=> delete assert
=> delete assert 28) in char_to_isrc()

ts A61008

------------------------------------------------------------------------------

++ 45) libburn/toc.c:				assert(0);	/* unhandled! find out ccd's
static write_clonecd2():

 - defunct -, - unused -

=> mangle assert

ts A61008

------------------------------------------------------------------------------

++ 46) libburn/toc.c:	assert(d->busy);
toc_find_modes():
The drive to work on is not marked busy

Called by mmc_read_toc() alias read_toc() by ... burn_drive_grab()

: Severe Libburn Error
=> to be prevented on the higher levels
=> delete assert

ts A61008

------------------------------------------------------------------------------

++ 47) libburn/util.c:	assert(s);
burn_strdup()
Abort on NULL string which would elsewise cause a SIGSEGV

Used once in enumerate_common() with a string that worked with open(2) before

: Severe Libburn Error
=> delete assert

ts A61008

------------------------------------------------------------------------------

++ 48) libburn/util.c:	assert(s);
burn_strndup(): - unused -
Same as 47

: Severe Libburn Error
=> return NULL
=> delete assert

ts A61008

------------------------------------------------------------------------------

++ 49) libburn/util.c:	assert(n > 0);
burn_strndup(): - unused -
Prevent problems by negative copy length

: Severe Libburn Error
=> return NULL
=> delete assert

ts A61008

------------------------------------------------------------------------------

++ 50) libburn/write.c:		assert(0);
static type_to_ctrl():
Unsuitable mode to be converted into "ctrl"
Called by static type_to_form() finally burn_create_toc_entries()

: Severe Application Error
=> to be caught in burn_track_define_data by calling for test type_to_form()
=> return -1;

ts A61008

------------------------------------------------------------------------------

++ 51) libburn/write.c:		assert(0);
       libburn/write.c:		assert(0);	/* XXX someone's gonna want this sometime */
static type_to_form():
Does not like BURN_MODE0 or BURN_MODE2 but tolerates unknown modes

Called by static burn_create_toc_entries() by burn_disc_write_sync()

: Undocumented Libburn Restriction
=> set *form = -1 , *ctladr = 0xff , return
=> make function non-static
=> call for test in API  burn_track_define_data()

ts A61009

------------------------------------------------------------------------------

++ 52) libburn/write.c:	assert(ptr);
static add_cue():
realloc() failed

Called by burn_create_toc_entries() by burn_disc_write_sync()
(burn_create_toc_entries is ignorant towards own potential memory problems)
(This could possibly really stay an abort() because the reason is
 a plain failure of the system's memory management.)

: Severe System Error
=> change return type of add_cue to int
=> react on return -1 in burn_create_toc_entries, return NULL on failure
=> abort burn_disc_write_sync() on NULL return

ts A61009

------------------------------------------------------------------------------

++ 53) libburn/write.c:	assert(d->toc_entry == NULL);
burn_create_toc_entries():
Multiple usage of struct burn_drive.toc_entry

Called by burn_disc_write_sync() 
This will probably trigger an abort with disc->sessions > 1
(disc->sessions is incremented in macro RESIZE() as "NEW##s")

: Design Problem
( => ? disallow multiple sessions ? )
=> replace assert by soft means and wait what happens

ts A61009

------------------------------------------------------------------------------

++ 54) libburn/write.c:	assert(0);
burn_sector_length():
Only BURN_AUDIO, BURN_MODE_RAW, BURN_MODE1 are allowed

Called by get_sector(), convert_data(), ...

=> call burn_sector_length() for test in API  burn_track_define_data()
=> replace assert by -1

ts A61009

------------------------------------------------------------------------------

