Replaced some large local variables by other means in libburn/drive.c
This commit is contained in:
parent
0c76daf2a9
commit
8fd81d4ec4
@ -1 +1 @@
|
||||
#define Cdrskin_timestamP "2011.05.15.181724"
|
||||
#define Cdrskin_timestamP "2011.05.15.191420"
|
||||
|
||||
168
libburn/drive.c
168
libburn/drive.c
@ -218,7 +218,10 @@ unsigned int burn_drive_count(void)
|
||||
int burn_drive_is_listed(char *path, struct burn_drive **found, int flag)
|
||||
{
|
||||
int i, ret;
|
||||
char drive_adr[BURN_DRIVE_ADR_LEN], off_adr[BURN_DRIVE_ADR_LEN];
|
||||
char *drive_adr = NULL, *off_adr = NULL;
|
||||
|
||||
BURN_ALLOC_MEM(drive_adr, char, BURN_DRIVE_ADR_LEN);
|
||||
BURN_ALLOC_MEM(off_adr, char, BURN_DRIVE_ADR_LEN);
|
||||
|
||||
ret = burn_drive_convert_fs_adr(path, off_adr);
|
||||
if (ret <= 0)
|
||||
@ -232,10 +235,14 @@ int burn_drive_is_listed(char *path, struct burn_drive **found, int flag)
|
||||
if(strcmp(off_adr, drive_adr) == 0) {
|
||||
if (found != NULL)
|
||||
*found= &(drive_array[i]);
|
||||
return 1;
|
||||
{ret= 1; goto ex;}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
ret= 0;
|
||||
ex:;
|
||||
BURN_FREE_MEM(drive_adr);
|
||||
BURN_FREE_MEM(off_adr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -451,10 +458,12 @@ int burn_drive_unregister(struct burn_drive *d)
|
||||
*/
|
||||
struct burn_drive *burn_drive_finish_enum(struct burn_drive *d)
|
||||
{
|
||||
struct burn_drive *t;
|
||||
char msg[BURN_DRIVE_ADR_LEN + 160];
|
||||
struct burn_drive *t = NULL;
|
||||
char *msg = NULL;
|
||||
int ret;
|
||||
|
||||
BURN_ALLOC_MEM(msg, char, BURN_DRIVE_ADR_LEN + 160);
|
||||
|
||||
d->drive_role = 1; /* MMC drive */
|
||||
|
||||
t = burn_drive_register(d);
|
||||
@ -483,6 +492,8 @@ struct burn_drive *burn_drive_finish_enum(struct burn_drive *d)
|
||||
/* ts A60821 */
|
||||
mmc_function_spy(NULL, "enumerate_common : ----- would release ");
|
||||
|
||||
ex:
|
||||
BURN_FREE_MEM(msg);
|
||||
return t;
|
||||
}
|
||||
|
||||
@ -703,7 +714,9 @@ void burn_disc_format_sync(struct burn_drive *d, off_t size, int flag)
|
||||
int ret, buf_secs, err, i, stages = 1, pbase, pfill, pseudo_sector;
|
||||
off_t num_bufs;
|
||||
char msg[80];
|
||||
struct buffer buf, *buf_mem = d->buffer;
|
||||
struct buffer *buf = NULL, *buf_mem = d->buffer;
|
||||
|
||||
BURN_ALLOC_MEM(buf, struct buffer, 1);
|
||||
|
||||
#ifdef Libburn_reset_progress_asynC
|
||||
/* <<< This is now done in async.c */
|
||||
@ -762,7 +775,7 @@ void burn_disc_format_sync(struct burn_drive *d, off_t size, int flag)
|
||||
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
|
||||
msg, 0, 0);
|
||||
|
||||
d->buffer = &buf;
|
||||
d->buffer = buf;
|
||||
memset(d->buffer, 0, sizeof(struct buffer));
|
||||
d->buffer->bytes = buf_secs * 2048;
|
||||
d->buffer->sectors = buf_secs;
|
||||
@ -790,6 +803,7 @@ ex:;
|
||||
d->progress.sector = 0x10000;
|
||||
d->busy = BURN_DRIVE_IDLE;
|
||||
d->buffer = buf_mem;
|
||||
BURN_FREE_MEM(buf);
|
||||
}
|
||||
|
||||
|
||||
@ -1408,7 +1422,7 @@ static int burn_drive__is_rdwr(char *fname, int *stat_ret,
|
||||
struct stat stbuf;
|
||||
off_t read_size = 0;
|
||||
|
||||
memset(&stbuf, 0, sizeof(stbuf));
|
||||
memset(&stbuf, 0, sizeof(struct stat));
|
||||
fd = burn_drive__fd_from_special_adr(fname);
|
||||
if (fd >= 0)
|
||||
st_ret = fstat(fd, &stbuf);
|
||||
@ -1446,7 +1460,7 @@ fprintf(stderr, "LIBBURN_DEBUG: burn_drive__is_rdwr: getfl_ret = %lX , O_RDWR =
|
||||
if (stat_ret != NULL)
|
||||
*stat_ret = st_ret;
|
||||
if (stbuf_ret != NULL)
|
||||
memcpy(stbuf_ret, &stbuf, sizeof(stbuf));
|
||||
memcpy(stbuf_ret, &stbuf, sizeof(struct stat));
|
||||
if (read_size_ret != NULL)
|
||||
*read_size_ret = read_size;
|
||||
return is_rdwr;
|
||||
@ -1691,18 +1705,21 @@ int burn_drive_scan_and_grab(struct burn_drive_info *drive_infos[], char* adr,
|
||||
int burn_drive_adr_debug_msg(char *fmt, char *arg)
|
||||
{
|
||||
int ret;
|
||||
char msg[4096], *msgpt;
|
||||
char *msg = NULL, *msgpt;
|
||||
|
||||
msgpt= msg;
|
||||
BURN_ALLOC_MEM(msg, char, 4096);
|
||||
msgpt = msg;
|
||||
if(arg != NULL)
|
||||
sprintf(msg, fmt, arg);
|
||||
else
|
||||
msgpt= fmt;
|
||||
msgpt = fmt;
|
||||
if(libdax_messenger == NULL)
|
||||
return 0;
|
||||
ret = libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
|
||||
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
|
||||
msgpt, 0, 0);
|
||||
ex:;
|
||||
BURN_FREE_MEM(msg);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1751,10 +1768,14 @@ int burn_drive_is_enumerable_adr(char *adr)
|
||||
int burn_drive_resolve_link(char *path, char adr[], int *recursion_count,
|
||||
int flag)
|
||||
{
|
||||
int ret;
|
||||
char link_target[4096], msg[4096+100], link_adr[4096], *adrpt;
|
||||
int ret, link_target_size = 4096;
|
||||
char *link_target = NULL, *msg = NULL, *link_adr = NULL, *adrpt;
|
||||
struct stat stbuf;
|
||||
|
||||
BURN_ALLOC_MEM(link_target, char, link_target_size);
|
||||
BURN_ALLOC_MEM(msg, char, link_target_size + 100);
|
||||
BURN_ALLOC_MEM(link_adr, char, link_target_size);
|
||||
|
||||
if (flag & 1)
|
||||
burn_drive_adr_debug_msg("burn_drive_resolve_link( %s )",
|
||||
path);
|
||||
@ -1763,24 +1784,24 @@ int burn_drive_resolve_link(char *path, char adr[], int *recursion_count,
|
||||
burn_drive_adr_debug_msg(
|
||||
"burn_drive_resolve_link aborts because link too deep",
|
||||
NULL);
|
||||
return 0;
|
||||
{ret = 0; goto ex;}
|
||||
}
|
||||
(*recursion_count)++;
|
||||
ret = readlink(path, link_target, sizeof(link_target));
|
||||
ret = readlink(path, link_target, link_target_size);
|
||||
if (ret == -1) {
|
||||
if (flag & 1)
|
||||
burn_drive_adr_debug_msg("readlink( %s ) returns -1",
|
||||
path);
|
||||
return 0;
|
||||
{ret = 0; goto ex;}
|
||||
}
|
||||
if (ret >= (int) sizeof(link_target) - 1) {
|
||||
if (ret >= link_target_size - 1) {
|
||||
sprintf(msg,"readlink( %s ) returns %d (too much)", path, ret);
|
||||
if (flag & 1)
|
||||
burn_drive_adr_debug_msg(msg, NULL);
|
||||
return -1;
|
||||
{ret = -1; goto ex;}
|
||||
}
|
||||
link_target[ret] = 0;
|
||||
adrpt= link_target;
|
||||
adrpt = link_target;
|
||||
if (link_target[0] != '/') {
|
||||
strcpy(link_adr, path);
|
||||
if ((adrpt = strrchr(link_adr, '/')) != NULL) {
|
||||
@ -1808,6 +1829,10 @@ int burn_drive_resolve_link(char *path, char adr[], int *recursion_count,
|
||||
}
|
||||
if (flag & 1)
|
||||
burn_drive_adr_debug_msg(msg, NULL);
|
||||
ex:;
|
||||
BURN_FREE_MEM(link_target);
|
||||
BURN_FREE_MEM(msg);
|
||||
BURN_FREE_MEM(link_adr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1815,13 +1840,16 @@ int burn_drive_resolve_link(char *path, char adr[], int *recursion_count,
|
||||
/* Try to find an enumerated address with the given stat.st_rdev number */
|
||||
int burn_drive_find_devno(dev_t devno, char adr[])
|
||||
{
|
||||
char fname[4096], msg[4096+100];
|
||||
int ret = 0, first = 1;
|
||||
char *fname = NULL, *msg = NULL;
|
||||
int ret = 0, first = 1, fname_size = 4096;
|
||||
struct stat stbuf;
|
||||
burn_drive_enumerator_t enm;
|
||||
|
||||
BURN_ALLOC_MEM(fname, char, fname_size);
|
||||
BURN_ALLOC_MEM(msg, char, fname_size + 100);
|
||||
|
||||
while (1) {
|
||||
ret = sg_give_next_adr(&enm, fname, sizeof(fname), first);
|
||||
ret = sg_give_next_adr(&enm, fname, fname_size, first);
|
||||
if(ret <= 0)
|
||||
break;
|
||||
first = 0;
|
||||
@ -1831,7 +1859,7 @@ int burn_drive_find_devno(dev_t devno, char adr[])
|
||||
if(devno != stbuf.st_rdev)
|
||||
continue;
|
||||
if(strlen(fname) >= BURN_DRIVE_ADR_LEN)
|
||||
return -1;
|
||||
{ret= -1; goto ex;}
|
||||
|
||||
sprintf(msg, "burn_drive_find_devno( 0x%lX ) found %s",
|
||||
(long) devno, fname);
|
||||
@ -1842,7 +1870,9 @@ int burn_drive_find_devno(dev_t devno, char adr[])
|
||||
ret = 0;
|
||||
ex:;
|
||||
if (first == 0)
|
||||
sg_give_next_adr(&enm, fname, sizeof(fname), -1);
|
||||
sg_give_next_adr(&enm, fname, fname_size, -1);
|
||||
BURN_FREE_MEM(fname);
|
||||
BURN_FREE_MEM(msg);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1855,7 +1885,9 @@ int burn_drive_obtain_scsi_adr(char *path,
|
||||
int *target_no, int *lun_no)
|
||||
{
|
||||
int ret, i;
|
||||
char adr[BURN_DRIVE_ADR_LEN];
|
||||
char *adr = NULL;
|
||||
|
||||
BURN_ALLOC_MEM(adr, char, BURN_DRIVE_ADR_LEN);
|
||||
|
||||
/* open drives cannot be inquired by sg_obtain_scsi_adr() */
|
||||
for (i = 0; i < drivetop + 1; i++) {
|
||||
@ -1863,7 +1895,7 @@ int burn_drive_obtain_scsi_adr(char *path,
|
||||
continue;
|
||||
ret = burn_drive_d_get_adr(&(drive_array[i]),adr);
|
||||
if (ret < 0)
|
||||
return -1;
|
||||
{ret = 1; goto ex;}
|
||||
if (ret == 0)
|
||||
continue;
|
||||
if (strcmp(adr, path) == 0) {
|
||||
@ -1874,13 +1906,15 @@ int burn_drive_obtain_scsi_adr(char *path,
|
||||
*bus_no = drive_array[i].bus_no;
|
||||
if (*host_no < 0 || *channel_no < 0 ||
|
||||
*target_no < 0 || *lun_no < 0)
|
||||
return 0;
|
||||
return 1;
|
||||
{ret = 0; goto ex;}
|
||||
{ret = 1; goto ex;}
|
||||
}
|
||||
}
|
||||
|
||||
ret = sg_obtain_scsi_adr(path, bus_no, host_no, channel_no,
|
||||
target_no, lun_no);
|
||||
ex:;
|
||||
BURN_FREE_MEM(adr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1888,17 +1922,20 @@ int burn_drive_obtain_scsi_adr(char *path,
|
||||
int burn_drive_convert_scsi_adr(int bus_no, int host_no, int channel_no,
|
||||
int target_no, int lun_no, char adr[])
|
||||
{
|
||||
char fname[4096],msg[4096+100];
|
||||
int ret = 0, first = 1, i_bus_no = -1;
|
||||
char *fname = NULL, *msg = NULL;
|
||||
int ret = 0, first = 1, i_bus_no = -1, fname_size = 4096;
|
||||
int i_host_no = -1, i_channel_no = -1, i_target_no = -1, i_lun_no = -1;
|
||||
burn_drive_enumerator_t enm;
|
||||
|
||||
BURN_ALLOC_MEM(fname, char, fname_size);
|
||||
BURN_ALLOC_MEM(msg, char, fname_size + 100);
|
||||
|
||||
sprintf(msg,"burn_drive_convert_scsi_adr( %d,%d,%d,%d,%d )",
|
||||
bus_no, host_no, channel_no, target_no, lun_no);
|
||||
burn_drive_adr_debug_msg(msg, NULL);
|
||||
|
||||
while (1) {
|
||||
ret= sg_give_next_adr(&enm, fname, sizeof(fname), first);
|
||||
ret= sg_give_next_adr(&enm, fname, fname_size, first);
|
||||
if(ret <= 0)
|
||||
break;
|
||||
first = 0;
|
||||
@ -1927,6 +1964,8 @@ int burn_drive_convert_scsi_adr(int bus_no, int host_no, int channel_no,
|
||||
ex:;
|
||||
if (first == 0)
|
||||
sg_give_next_adr(&enm, fname, sizeof(fname), -1);
|
||||
BURN_FREE_MEM(fname);
|
||||
BURN_FREE_MEM(msg);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -2813,12 +2852,16 @@ static int burn__split_path(char *adr, char **dpt, char **npt)
|
||||
int burn_drive_equals_adr(struct burn_drive *d1, char *adr2_in, int role2)
|
||||
{
|
||||
struct stat stbuf1, stbuf2;
|
||||
char adr1[BURN_DRIVE_ADR_LEN], *adr2 = adr2_in;
|
||||
char conv_adr1[BURN_DRIVE_ADR_LEN], conv_adr2[BURN_DRIVE_ADR_LEN];
|
||||
char *adr1 = NULL, *adr2 = adr2_in;
|
||||
char *conv_adr1 = NULL, *conv_adr2 = NULL;
|
||||
char *npt1, *dpt1, *npt2, *dpt2;
|
||||
int role1, stat_ret1, stat_ret2, conv_ret2, exact_role_matters = 0, fd;
|
||||
int ret;
|
||||
|
||||
BURN_ALLOC_MEM(adr1, char, BURN_DRIVE_ADR_LEN);
|
||||
BURN_ALLOC_MEM(conv_adr1, char, BURN_DRIVE_ADR_LEN);
|
||||
BURN_ALLOC_MEM(conv_adr2, char, BURN_DRIVE_ADR_LEN);
|
||||
|
||||
role1 = burn_drive_get_drive_role(d1);
|
||||
burn_drive_d_get_adr(d1, adr1);
|
||||
stat_ret1 = stat(adr1, &stbuf1);
|
||||
@ -2856,7 +2899,7 @@ int burn_drive_equals_adr(struct burn_drive *d1, char *adr2_in, int role2)
|
||||
}
|
||||
|
||||
if (strlen(adr2) >= BURN_DRIVE_ADR_LEN)
|
||||
return -1;
|
||||
{ret = -1; goto ex;}
|
||||
stat_ret2 = stat(adr2, &stbuf2);
|
||||
conv_ret2 = burn_drive_convert_fs_adr(adr2, conv_adr2);
|
||||
|
||||
@ -2870,26 +2913,27 @@ int burn_drive_equals_adr(struct burn_drive *d1, char *adr2_in, int role2)
|
||||
}
|
||||
|
||||
if (strcmp(adr1, adr2) == 0 && role1 == role2)
|
||||
return(1); /* equal role and address */
|
||||
{ret = 1; goto ex;} /* equal role and address */
|
||||
if (role1 == 1 && role2 == 1) {
|
||||
/* MMC drive meets wannabe MMC drive */
|
||||
if (conv_ret2 <= 0)
|
||||
return 0; /* no MMC drive at adr2 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr2 */
|
||||
if (strcmp(adr1, conv_adr2) == 0)
|
||||
return 1; /* equal real MMC drives */
|
||||
return 0;
|
||||
{ret = 1; goto ex;} /* equal real MMC drives */
|
||||
{ret = 0; goto ex;}
|
||||
|
||||
} else if (role1 == 0 || role2 == 0)
|
||||
return 0; /* one null-drive, one not */
|
||||
{ret = 0; goto ex;} /* one null-drive, one not */
|
||||
|
||||
else if (role1 != 1 && role2 != 1) {
|
||||
/* pseudo-drive meets file object */
|
||||
|
||||
if (role1 != role2)
|
||||
return 0;
|
||||
{ret = 0; goto ex;}
|
||||
if (stat_ret1 == -1 || stat_ret2 == -1) {
|
||||
if (stat_ret1 != -1 || stat_ret2 != -1)
|
||||
return 0; /* one adress existing, one not */
|
||||
{ret = 0; goto ex;}
|
||||
/* one adress existing, one not */
|
||||
|
||||
/* Two non-existing file objects */
|
||||
|
||||
@ -2898,11 +2942,12 @@ int burn_drive_equals_adr(struct burn_drive *d1, char *adr2_in, int role2)
|
||||
strcpy(conv_adr2, adr2);
|
||||
burn__split_path(conv_adr2, &dpt2, &npt2);
|
||||
if (strcmp(npt1, npt2))
|
||||
return 0; /* basenames differ */
|
||||
{ret = 0; goto ex;} /* basenames differ */
|
||||
stat_ret1= stat(adr1, &stbuf1);
|
||||
stat_ret2= stat(adr2, &stbuf2);
|
||||
if (stat_ret1 != stat_ret2)
|
||||
return 0; /* one dir existing, one not */
|
||||
{ret = 0; goto ex;}
|
||||
/* one dir existing, one not */
|
||||
|
||||
/* Both directories exist. The basenames are equal.
|
||||
So the adresses are equal if the directories are
|
||||
@ -2910,47 +2955,52 @@ int burn_drive_equals_adr(struct burn_drive *d1, char *adr2_in, int role2)
|
||||
}
|
||||
if (stbuf1.st_ino == stbuf2.st_ino &&
|
||||
stbuf1.st_dev == stbuf2.st_dev)
|
||||
return 1; /* same filesystem object */
|
||||
{ret = 1; goto ex;} /* same filesystem object */
|
||||
|
||||
if (S_ISBLK(stbuf1.st_mode) && S_ISBLK(stbuf2.st_mode) &&
|
||||
stbuf1.st_rdev == stbuf2.st_rdev)
|
||||
return 1; /* same major,minor device number */
|
||||
{ret = 1; goto ex;}/* same major,minor device number */
|
||||
if (S_ISCHR(stbuf1.st_mode) && S_ISCHR(stbuf2.st_mode) &&
|
||||
stbuf1.st_rdev == stbuf2.st_rdev)
|
||||
return 1; /* same major,minor device number */
|
||||
{ret = 1; goto ex;}/* same major,minor device number */
|
||||
|
||||
/* Are both filesystem objects related to the same MMC drive */
|
||||
if (conv_ret2 <= 0)
|
||||
return 0; /* no MMC drive at adr2 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr2 */
|
||||
if (burn_drive_convert_fs_adr(adr1, conv_adr1) <= 0)
|
||||
return 0; /* no MMC drive at adr1 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr1 */
|
||||
if (strcmp(conv_adr1, conv_adr2) == 0)
|
||||
return 1; /* same MMC drive */
|
||||
{ret = 1; goto ex;} /* same MMC drive */
|
||||
|
||||
return 0; /* all filesystem disguises are checked */
|
||||
{ret = 0; goto ex;} /* all filesystem disguises are checked */
|
||||
|
||||
} else if (role1 == 1 && role2 != 1) {
|
||||
/* MMC drive meets file object */
|
||||
|
||||
if (conv_ret2 <= 0)
|
||||
return 0; /* no MMC drive at adr2 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr2 */
|
||||
if (strcmp(adr1, conv_adr2) == 0)
|
||||
return 1; /* same MMC drive */
|
||||
return 0;
|
||||
{ret = 1; goto ex;} /* same MMC drive */
|
||||
{ret = 0; goto ex;}
|
||||
|
||||
} else if (role1 != 1 && role2 == 1) {
|
||||
/* stdio-drive meets wannabe MMC drive */
|
||||
|
||||
if (conv_ret2 <= 0)
|
||||
return 0; /* no MMC drive at adr2 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr2 */
|
||||
if (burn_drive_convert_fs_adr(adr1, conv_adr1) <= 0)
|
||||
return 0; /* no MMC drive at adr1 */
|
||||
{ret = 0; goto ex;} /* no MMC drive at adr1 */
|
||||
if (strcmp(conv_adr1, conv_adr2) == 0)
|
||||
return 1; /* same MMC drive */
|
||||
return 0;
|
||||
{ret = 1; goto ex;} /* same MMC drive */
|
||||
{ret = 0; goto ex;}
|
||||
|
||||
}
|
||||
return 0; /* now i believe they are really not equal */
|
||||
ret = 0;
|
||||
ex:;
|
||||
BURN_FREE_MEM(adr1);
|
||||
BURN_FREE_MEM(conv_adr1);
|
||||
BURN_FREE_MEM(conv_adr2);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user