int
main(int argc, char **argv)
{
test_create_dynamic() ;
test_create_static() ;
test_thread_create() ;
test_yield() ;
test_wait() ;
test_broadcast() ;
test_pc() ;
test_pc_big() ;
test_recursive() ;
test_sem() ;
test_lock() ;
test_func_pointer() ;
test_ready() ;
test_kill() ;
test_reset() ;
return 0 ;
}
uint32_t i2c_tx_rx(i2c_t i2c, uint8_t addr, const uint8_t *tx_buffer,
uint16_t tx_length, uint8_t *rx_buffer, uint16_t rx_length)
{
_i2c_t *_i2c = i2c;
// Do the before-transfer test
test_ready(_i2c);
// Copy the data to send, data to read. Set the current state for the
// I2C state machine and the issue the start condition.
address = addr;
len_send = tx_length;
cpt_send = 0;
buf_send = tx_buffer;
len_recv = rx_length;
cpt_recv = 0;
buf_recv = rx_buffer;
state = I2C_SENDING_START;
// Set ACK bit before starting anything
*i2c_get_CR1(_i2c) |= I2C_CR1__ACK;
// Generate START condition to initiate the transfer
*i2c_get_CR1(_i2c) |= I2C_CR1__START;
while ((state != I2C_IDLE) && (state != I2C_ERROR))
{
}
// Wait until busy is cleared
while (*i2c_get_SR2(_i2c) & I2C_SR2__BUSY)
{
}
return (state != I2C_IDLE);
}
/*
* Start a transfer
*/
static void tx_rx_start(const _i2c_t *_i2c, uint8_t addr, const uint8_t *tx_buffer,
uint16_t tx_length, uint8_t *rx_buffer, uint16_t rx_length,
result_handler_t handler, handler_arg_t arg)
{
_i2c_data_t *const data = _i2c->data;
// Do the before-transfer test
test_ready(_i2c);
// Save the handler
data->transfer_handler = handler;
data->transfer_handler_arg = arg;
// Copy the data to send, data to read. Set the current state for the
// I2C state machine and the issue the start condition.
data->address = addr;
data->len_send = tx_length;
data->cpt_send = 0;
data->buf_send = tx_buffer;
data->len_recv = rx_length;
data->cpt_recv = 0;
data->buf_recv = rx_buffer;
// Ensure POS bit is cleared
*i2c_get_CR1(_i2c) &= ~I2C_CR1__POS;
data->state = I2C_SENDING_START;
// Set ACK bit before starting anything
*i2c_get_CR1(_i2c) |= I2C_CR1__ACK;
// Generate START condition to initiate the transfer
*i2c_get_CR1(_i2c) |= I2C_CR1__START;
}
/* in order to save builtin numbers, create a single socket function with
* options socket_request(SockOperation,....) */
xsbBool xsb_socket_request(CTXTdecl)
{
int ecode = 0; /* error code for socket ops */
int timeout_flag;
SOCKET sock_handle;
int domain, portnum;
SOCKADDR_IN socket_addr;
struct linger sock_linger_opt;
int rc;
char *message_buffer = NULL; /* initialized to keep compiler happy */
UInteger msg_len = 0; /* initialized to keep compiler happy */
char char_read;
switch (ptoc_int(CTXTc 1)) {
case SOCKET_ROOT: /* this is the socket() request */
/* socket_request(SOCKET_ROOT,+domain,-socket_fd,-Error,_,_,_)
Currently only AF_INET domain */
domain = (int)ptoc_int(CTXTc 2);
if (!translate_domain(domain, &domain)) {
return FALSE;
}
sock_handle = socket(domain, SOCK_STREAM, IPPROTO_TCP);
/* error handling */
if (BAD_SOCKET(sock_handle)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_REQUEST");
} else {
ecode = SOCK_OK;
}
ctop_int(CTXTc 3, (SOCKET) sock_handle);
return set_error_code(CTXTc ecode, 4, "SOCKET_REQUEST");
case SOCKET_BIND:
/* socket_request(SOCKET_BIND,+domain,+sock_handle,+port,-Error,_,_)
Currently only supports AF_INET */
sock_handle = (SOCKET) ptoc_int(CTXTc 3);
portnum = (int)ptoc_int(CTXTc 4);
domain = (int)ptoc_int(CTXTc 2);
if (!translate_domain(domain, &domain)) {
return FALSE;
}
/* Bind server to the agreed upon port number.
** See commdef.h for the actual port number. */
FillWithZeros(socket_addr);
socket_addr.sin_port = htons((unsigned short)portnum);
socket_addr.sin_family = AF_INET;
#ifndef WIN_NT
socket_addr.sin_addr.s_addr = htonl(INADDR_ANY);
#endif
rc = bind(sock_handle, (PSOCKADDR) &socket_addr, sizeof(socket_addr));
/* error handling */
if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_BIND");
} else
ecode = SOCK_OK;
return set_error_code(CTXTc ecode, 5, "SOCKET_BIND");
case SOCKET_LISTEN:
/* socket_request(SOCKET_LISTEN,+sock_handle,+length,-Error,_,_,_) */
sock_handle = (SOCKET) ptoc_int(CTXTc 2);
rc = listen(sock_handle, (int)ptoc_int(CTXTc 3));
/* error handling */
if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_LISTEN");
} else
ecode = SOCK_OK;
return set_error_code(CTXTc ecode, 4, "SOCKET_LISTEN");
case SOCKET_ACCEPT:
timeout_flag = socket_accept(CTXTc (SOCKET *)&rc, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 4, "SOCKET_SEND");
} else {
/* error handling */
if (BAD_SOCKET(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_ACCEPT");
sock_handle = rc; /* shut up warning */
} else {
sock_handle = rc; /* accept() returns sock_out */
ecode = SOCK_OK;
}
ctop_int(CTXTc 3, (SOCKET) sock_handle);
return set_error_code(CTXTc ecode, 4, "SOCKET_ACCEPT");
}
case SOCKET_CONNECT: {
/* socket_request(SOCKET_CONNECT,+domain,+sock_handle,+port,
+hostname,-Error) */
timeout_flag = socket_connect(CTXTc &rc, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 6, "SOCKET_CONNECT");
} else if (timeout_flag == TIMER_SETUP_ERR) {
return set_error_code(CTXTc TIMER_SETUP_ERR, 6, "SOCKET_CONNECT");
} else {
/* error handling */
if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_CONNECT");
/* close, because if connect() fails then socket becomes unusable */
closesocket(ptoc_int(CTXTc 3));
} else {
ecode = SOCK_OK;
}
return set_error_code(CTXTc ecode, 6, "SOCKET_CONNECT");
}
}
case SOCKET_CLOSE:
/* socket_request(SOCKET_CLOSE,+sock_handle,-Error,_,_,_,_) */
sock_handle = (SOCKET)ptoc_int(CTXTc 2);
/* error handling */
rc = closesocket(sock_handle);
if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_CLOSE");
} else
ecode = SOCK_OK;
return set_error_code(CTXTc ecode, 3, "SOCKET_CLOSE");
case SOCKET_RECV:
/* socket_request(SOCKET_RECV,+Sockfd, -Msg, -Error,_,_,_) */
// TODO: consider adding protection against interrupts, EINTR, like
// in socket_get0.
timeout_flag = socket_recv(CTXTc &rc, &message_buffer, &msg_len, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 4, "SOCKET_SEND");
} else {
/* error handling */
switch (rc) {
case SOCK_OK:
ecode = SOCK_OK;
break;
case SOCK_READMSG_FAILED:
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_RECV");
break;
case SOCK_READMSG_EOF:
ecode = SOCK_EOF;
break;
case SOCK_HEADER_LEN_MISMATCH:
ecode = XSB_SOCKET_ERRORCODE;
break;
default:
xsb_abort("XSB bug: [SOCKET_RECV] invalid return code from readmsg");
}
if (message_buffer != NULL) {
/* use message_buffer+XSB_MSG_HEADER_LENGTH because the first
XSB_MSG_HEADER_LENGTH bytes are for the message length header */
ctop_string(CTXTc 3, (char*)message_buffer+XSB_MSG_HEADER_LENGTH);
mem_dealloc(message_buffer,msg_len,OTHER_SPACE);
} else { /* this happens at the end of a file */
ctop_string(CTXTc 3, (char*)"");
}
return set_error_code(CTXTc ecode, 4, "SOCKET_RECV");
}
case SOCKET_SEND:
/* socket_request(SOCKET_SEND,+Sockfd, +Msg, -Error,_,_,_) */
timeout_flag = socket_send(CTXTc &rc, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 4, "SOCKET_SEND");
} else {
/* error handling */
if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_SEND");
} else {
ecode = SOCK_OK;
}
return set_error_code(CTXTc ecode, 4, "SOCKET_SEND");
}
case SOCKET_GET0:
/* socket_request(SOCKET_GET0,+Sockfd,-C,-Error,_,_,_) */
message_buffer = &char_read;
timeout_flag = socket_get0(CTXTc &rc, message_buffer, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 4, "SOCKET_SEND");
} else {
/*error handling */
switch (rc) {
case 1:
ctop_int(CTXTc 3,(unsigned char)message_buffer[0]);
ecode = SOCK_OK;
break;
case 0:
ecode = SOCK_EOF;
break;
default:
ctop_int(CTXTc 3,-1);
perror("SOCKET_GET0");
ecode = XSB_SOCKET_ERRORCODE;
}
return set_error_code(CTXTc ecode, 4, "SOCKET_GET0");
}
case SOCKET_PUT:
/* socket_request(SOCKET_PUT,+Sockfd,+C,-Error_,_,_) */
timeout_flag = socket_put(CTXTc &rc, (int)pflags[SYS_TIMER]);
if (timeout_flag == TIMED_OUT) {
return set_error_code(CTXTc TIMEOUT_ERR, 4, "SOCKET_SEND");
} else {
/* error handling */
if (rc == 1) {
ecode = SOCK_OK;
} else if (SOCKET_OP_FAILED(rc)) {
ecode = XSB_SOCKET_ERRORCODE;
perror("SOCKET_PUT");
}
return set_error_code(CTXTc ecode, 4, "SOCKET_PUT");
}
case SOCKET_SET_OPTION: {
/* socket_request(SOCKET_SET_OPTION,+Sockfd,+OptionName,+Value,_,_,_) */
char *option_name = ptoc_string(CTXTc 3);
sock_handle = (SOCKET)ptoc_int(CTXTc 2);
/* Set the "linger" parameter to a small number of seconds */
if (0==strcmp(option_name,"linger")) {
int linger_time=(int)ptoc_int(CTXTc 4);
if (linger_time < 0) {
sock_linger_opt.l_onoff = FALSE;
sock_linger_opt.l_linger = 0;
} else {
sock_linger_opt.l_onoff = TRUE;
sock_linger_opt.l_linger = linger_time;
}
if (SETSOCKOPT(sock_handle, SOL_SOCKET, SO_LINGER,
&sock_linger_opt, sizeof(sock_linger_opt))
< 0) {
xsb_warn(CTXTc "[SOCKET_SET_OPTION] Cannot set socket linger time");
return FALSE;
}
}else {
xsb_warn(CTXTc "[SOCKET_SET_OPTION] Invalid option, `%s'", option_name);
return FALSE;
}
return TRUE;
}
case SOCKET_SET_SELECT: {
/*socket_request(SOCKET_SET_SELECT,+connection_name,
+R_sockfd,+W_sockfd,+E_sockfd) */
prolog_term R_sockfd, W_sockfd, E_sockfd;
int i, connection_count;
int rmax_fd=0, wmax_fd=0, emax_fd=0;
char *connection_name = ptoc_string(CTXTc 2);
/* bind fds to input arguments */
R_sockfd = reg_term(CTXTc 3);
W_sockfd = reg_term(CTXTc 4);
E_sockfd = reg_term(CTXTc 5);
/* initialize the array of connect_t structure for select call */
init_connections(CTXT);
SYS_MUTEX_LOCK(MUTEX_SOCKETS);
/* check whether the same connection name exists */
for (i=0;i<MAXCONNECT;i++) {
if ((connections[i].empty_flag==FALSE) &&
(strcmp(connection_name,connections[i].connection_name)==0))
xsb_abort("[SOCKET_SET_SELECT] Connection `%s' already exists!",
connection_name);
}
/* check whether there is empty slot left for connection */
if ((connection_count=checkslot())<MAXCONNECT) {
if (connections[connection_count].connection_name == NULL) {
connections[connection_count].connection_name = connection_name;
connections[connection_count].empty_flag = FALSE;
/* call the utility function separately to take the fds in */
list_sockfd(R_sockfd, &connections[connection_count].readset,
&rmax_fd, &connections[connection_count].read_fds,
&connections[connection_count].sizer);
list_sockfd(W_sockfd, &connections[connection_count].writeset,
&wmax_fd, &connections[connection_count].write_fds,
&connections[connection_count].sizew);
list_sockfd(E_sockfd, &connections[connection_count].exceptionset,
&emax_fd,&connections[connection_count].exception_fds,
&connections[connection_count].sizee);
connections[connection_count].maximum_fd =
xsb_max(xsb_max(rmax_fd,wmax_fd), emax_fd);
} else
/* if this one is reached, it is probably a bug */
xsb_abort("[SOCKET_SET_SELECT] All connections are busy!");
} else
xsb_abort("[SOCKET_SET_SELECT] Max number of collections exceeded!");
SYS_MUTEX_UNLOCK(MUTEX_SOCKETS);
return TRUE;
}
case SOCKET_SELECT: {
/* socket_request(SOCKET_SELECT,+connection_name, +timeout
-avail_rsockfds,-avail_wsockfds,
-avail_esockfds,-ecode)
Returns 3 prolog_terms for available socket fds */
prolog_term Avail_rsockfds, Avail_wsockfds, Avail_esockfds;
prolog_term Avail_rsockfds_tail, Avail_wsockfds_tail, Avail_esockfds_tail;
int maxfd;
int i; /* index for connection_count */
char *connection_name = ptoc_string(CTXTc 2);
struct timeval *tv;
prolog_term timeout_term;
int timeout =0;
int connectname_found = FALSE;
int count=0;
SYS_MUTEX_LOCK(MUTEX_SOCKETS);
/* specify the time out */
timeout_term = reg_term(CTXTc 3);
if (isointeger(timeout_term)) {
timeout = (int)oint_val(timeout_term);
/* initialize tv */
tv = (struct timeval *)mem_alloc(sizeof(struct timeval),LEAK_SPACE);
tv->tv_sec = timeout;
tv->tv_usec = 0;
} else
tv = NULL; /* no timeouts */
/* initialize the prolog term */
Avail_rsockfds = p2p_new(CTXT);
Avail_wsockfds = p2p_new(CTXT);
Avail_esockfds = p2p_new(CTXT);
/* bind to output arguments */
Avail_rsockfds = reg_term(CTXTc 4);
Avail_wsockfds = reg_term(CTXTc 5);
Avail_esockfds = reg_term(CTXTc 6);
Avail_rsockfds_tail = Avail_rsockfds;
Avail_wsockfds_tail = Avail_wsockfds;
Avail_esockfds_tail = Avail_esockfds;
/*
// This was wrong. Lists are now made inside test_ready()
c2p_list(CTXTc Avail_rsockfds_tail);
c2p_list(CTXTc Avail_wsockfds_tail);
c2p_list(CTXTc Avail_esockfds_tail);
*/
for (i=0; i < MAXCONNECT; i++) {
/* find the matching connection_name to select */
if(connections[i].empty_flag==FALSE) {
if (strcmp(connection_name, connections[i].connection_name) == 0) {
connectname_found = TRUE;
count = i;
break;
}
}
}
if( i >= MAXCONNECT ) /* if no matching connection_name */
xsb_abort("[SOCKET_SELECT] connection `%s' doesn't exist",
connection_name);
/* compute maxfd for select call */
maxfd = connections[count].maximum_fd + 1;
/* FD_SET all sockets */
set_sockfd( CTXTc count );
/* test whether the socket fd is available */
rc = select(maxfd, &connections[count].readset,
&connections[count].writeset,
&connections[count].exceptionset, tv);
/* error handling */
if (rc == 0) /* timed out */
ecode = TIMEOUT_ERR;
else if (SOCKET_OP_FAILED(rc)) {
perror("SOCKET_SELECT");
ecode = XSB_SOCKET_ERRORCODE;
} else { /* no error */
ecode = SOCK_OK;
/* call the utility function to return the available socket fds */
test_ready(CTXTc &Avail_rsockfds_tail, &connections[count].readset,
connections[count].read_fds,connections[count].sizer);
test_ready(CTXTc &Avail_wsockfds_tail, &connections[count].writeset,
connections[count].write_fds,connections[count].sizew);
test_ready(CTXTc &Avail_esockfds_tail,&connections[count].exceptionset,
connections[count].exception_fds,connections[count].sizee);
}
SYS_MUTEX_UNLOCK(MUTEX_SOCKETS);
if (tv) mem_dealloc((struct timeval *)tv,sizeof(struct timeval),LEAK_SPACE);
SQUASH_LINUX_COMPILER_WARN(connectname_found) ;
return set_error_code(CTXTc ecode, 7, "SOCKET_SELECT");
}
case SOCKET_SELECT_DESTROY: {
/*socket_request(SOCKET_SELECT_DESTROY, +connection_name) */
char *connection_name = ptoc_string(CTXTc 2);
select_destroy(CTXTc connection_name);
return TRUE;
}
default:
xsb_warn(CTXTc "[SOCKET_REQUEST] Invalid socket request %d", (int) ptoc_int(CTXTc 1));
return FALSE;
}
/* This trick would report a bug, if a newly added case
doesn't have a return clause */
xsb_bug("SOCKET_REQUEST case %d has no return clause", ptoc_int(CTXTc 1));
}
int main(int argc, char **argv)
{
iso_primary_descriptor_type ipd;
char *dev = default_dev;
char vendor[9],model[17],rev[5];
unsigned char reply[1024];
char tmpstr[255];
int replylen=sizeof(reply);
int trackno = 0;
int info_only = 0;
unsigned char *buffer;
int buffersize = READBLOCKS*BLOCKSIZE;
int start,stop,imagesize=0,tracksize=0;
int counter = 0;
long readsize = 0;
long imagesize_bytes = 0;
int drive_block_size, init_bsize;
int force_mode = 0;
int scanbus_mode = 0;
int dump_start, dump_count;
MD5_CTX *MD5;
char digest[16],digest_text[33];
int md5_mode = 0;
int opt_index = 0;
int audio_track = 0;
int readblocksize = BLOCKSIZE;
int file_format = AF_FILE_AIFFC;
#ifdef IRIX
CDPARSER *cdp = CDcreateparser();
CDFRAME cdframe;
#endif
int dev_type;
int i,c,o;
int len;
int start_time,cur_time,kbps;
if (rcsid);
MD5 = malloc(sizeof(MD5_CTX));
buffer=(unsigned char*)malloc(READBLOCKS*AUDIOBLOCKSIZE);
if (!buffer || !MD5) die("No memory");
if (argc<2) die("parameter(s) missing\n"
"Try '%s --help' for more information.\n",PRGNAME);
/* parse command line parameters */
while(1) {
if ((c=getopt_long(argc,argv,"SMmvhid:",long_options,&opt_index))
== -1) break;
switch (c) {
case 'a':
file_format=AF_FILE_AIFF;
break;
case 'A':
file_format=AF_FILE_AIFFC;
break;
case 'v':
verbose_mode=1;
break;
case 'h':
p_usage();
break;
case 'd':
dev=strdup(optarg);
break;
case 't':
if (sscanf(optarg,"%d",&trackno)!=1) trackno=0;
break;
case 'i':
info_only=1;
break;
case 'c':
if (sscanf(optarg,"%d,%d",&dump_start,&dump_count)!=2)
die("invalid parameters");
dump_mode=1;
break;
#ifdef IRIX
case 'C':
if (sscanf(optarg,"%d,%d",&dump_start,&dump_count)!=2)
die("invalid parameters");
dump_mode=2;
break;
#endif
case 'f':
if (sscanf(optarg,"%d",&force_mode)!=1) die("invalid parameters");
if (force_mode<1 || force_mode >2) {
die("invalid parameters");
}
break;
case 'm':
md5_mode=1;
break;
case 'M':
md5_mode=2;
break;
case 's':
audio_mode=1;
break;
case 'S':
scanbus_mode=1;
break;
case 'V':
printf(PRGNAME " " VERSION " " HOST_TYPE
"\nCopyright (c) Timo Kokkonen, 1997-1998.\n\n");
exit(0);
break;
case '?':
break;
default:
die("error parsing parameters");
}
}
if (!info_only) {
if (md5_mode==2) outfile=fopen("/dev/null","w");
else outfile=fopen(argv[optind],"w");
if (!outfile) {
if (argv[optind]) die("cannot open output file '%s'",argv[optind]);
info_only=1;
}
}
printf("readiso(9660) " VERSION "\n");
/* open the scsi device */
if (scsi_open(dev)) die("error opening scsi device '%s'",dev);
if (scanbus_mode) {
printf("\n");
scan_bus();
exit(0);
}
memset(reply,0,sizeof(reply));
if ((dev_type=inquiry(vendor,model,rev))<0)
die("error accessing scsi device");
if (verbose_mode) {
printf("device: %s\n",dev);
printf("Vendor: %s\nModel: %s\nRevision: %s\n",vendor,model,rev);
}
if ( (dev_type&0x1f) != 0x5 ) {
die("Device doesn't seem to be a CD-ROM!");
}
#ifdef IRIX
if (strcmp(vendor,"TOSHIBA")) {
warn("NOTE! Audio track reading probably not supported on this device.\n");
}
#endif
test_ready();
if (test_ready()!=0) {
sleep(2);
if (test_ready()!=0) die("device not ready");
}
fprintf(stderr,"Initializing...\n");
if (audio_mode) {
#ifdef IRIX
audioport=ALopenport("readiso","w",0);
if (!audioport) {
warn("Cannot initialize audio.");
audio_mode=0;
}
#else
audio_mode=0;
#endif
}
#ifdef IRIX
/* Make sure we get sane underflow exception handling */
sigfpe_[_UNDERFL].repls = _ZERO;
handle_sigfpes(_ON, _EN_UNDERFL, NULL, _ABORT_ON_ERROR, NULL);
#endif
/* set_removable(1); */
#if 0
replylen=255;
if (mode_sense10(reply,&replylen)==0) {
printf("replylen=%d blocks=%d blocklen=%d\n",replylen,
V3(&reply[8+1]),V3(&reply[8+5]));
PRINT_BUF(reply,replylen);
}
replylen=255; /* sizeof(reply); */
if (mode_sense(reply,&replylen)==0) {
printf("replylen=%d blocks=%d blocklen=%d\n",replylen,
V3(&reply[4+1]),V3(&reply[4+5]));
PRINT_BUF(reply,replylen);
}
#endif
if (dump_mode==2) init_bsize=AUDIOBLOCKSIZE;
else init_bsize=BLOCKSIZE;
start_stop(0);
if ( (drive_block_size=get_block_size()) < 0 ) {
warn("cannot get current block size");
drive_block_size=init_bsize;
}
if (drive_block_size != init_bsize) {
mode_select(init_bsize,(dump_mode==2?0x82:0x00));
drive_block_size=get_block_size();
if (drive_block_size!=init_bsize) warn("cannot set drive block size.");
}
start_stop(1);
if (dump_mode && !info_only) {
#ifdef IRIX
CDFRAME buf;
if (dump_mode==2) {
if (cdp) {
CDaddcallback(cdp, cd_audio, (CDCALLBACKFUNC)playaudio, 0);
} else die("No audioparser");
}
#endif
fprintf(stderr,"Dumping %d sector(s) starting from LBA=%d\n",
dump_count,dump_start);
for (i=dump_start;i<dump_start+dump_count;i++) {
len=buffersize;
read_10(i,1,buffer,&len);
if (len<init_bsize) break;
#ifdef IRIX
if (dump_mode==2) {
memcpy(&buf,buffer,CDDA_BLOCKSIZE);
CDparseframe(cdp,&buf);
}
#endif
fwrite(buffer,len,1,outfile);
fprintf(stderr,".");
}
fprintf(stderr,"\ndone.\n");
goto quit;
}
fprintf(stderr,"Reading disc TOC...");
replylen=sizeof(reply);
read_toc(reply,&replylen,verbose_mode);
printf("\n");
if (trackno==0) { /* try to find first data track */
for (i=0;i<(reply[3]-reply[2]+1);i++) {
o=4+i*8;
if (reply[o+1]&DATA_TRACK) { trackno=i+1; break; }
}
if (trackno==0) die("No data track(s) found.");
}
fprintf(stderr,"Reading track %d...\n",trackno);
if ( (trackno < reply[2]) || (trackno > reply[3]) )
die("Invalid track specified.");
if ( ((reply[(trackno-1)*8+4+1]&DATA_TRACK)==0) ) {
fprintf(stderr,"Not a data track.\n");
mode_select(AUDIOBLOCKSIZE,0x82);
if (mode_sense(reply,&replylen)!=0) die("cannot get sense data");
drive_block_size=V3(&reply[9]);
fprintf(stderr,"Selecting CD-DA mode, output file format: %s\n",
file_format==AF_FILE_AIFFC?"AIFFC":"AIFF");
audio_track=1;
} else {
audio_track=0;
}
start=V4(&reply[(trackno-1)*8+4+4]);
stop=V4(&reply[(trackno)*8+4+4]);
tracksize=abs(stop-start);
/* if (verbose_mode) printf("Start LBA=%d\nStop LBA=%d\n",start,stop); */
len=buffersize;
read_10(start-0,1,buffer,&len);
/* PRINT_BUF(buffer,32); */
if (!audio_track) {
/* read the iso9660 primary descriptor */
fprintf(stderr,"Reading ISO9660 primary descriptor...\n");
len=buffersize;
read_10(start+16,1,buffer,&len);
if (len<sizeof(ipd)) die("cannot read iso9660 primary descriptor.");
memcpy(&ipd,buffer,sizeof(ipd));
imagesize=ISONUM(ipd.volume_space_size);
/* we should really check here if we really got a valid primary
descriptor or not... */
if ( (imagesize>(stop-start)) || (imagesize<1) ) {
fprintf(stderr,"\aInvalid ISO primary descriptor!!!\n");
if (!info_only) fprintf(stderr,"Copying entire track to image file.\n");
force_mode=2;
}
if (force_mode==1) {} /* use size from ISO primary descriptor */
else if (force_mode==2) imagesize=tracksize; /* use size from TOC */
else {
if ( ( (tracksize-imagesize) > MAX_DIFF_ALLOWED ) ||
( imagesize > tracksize ) ) {
fprintf(stderr,"ISO primary descriptor has suspicious volume size"
" (%d blocks)\n",imagesize);
imagesize=tracksize;
fprintf(stderr,
"Using track size from TOC record (%d blocks) instead.\n",
imagesize);
fprintf(stderr,
"(option -f can be used to override this behaviour.)\n");
}
}
imagesize_bytes=imagesize*BLOCKSIZE;
if (verbose_mode||info_only) {
printf("ISO9660 image info:\n");
printf("Type: %02xh\n",ipd.type[0]);
ISOGETSTR(tmpstr,ipd.id,5);
printf("ID: %s\n",tmpstr);
printf("Version: %u\n",ipd.version[0]);
ISOGETSTR(tmpstr,ipd.system_id,32);
printf("System id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.volume_id,32);
printf("Volume id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.volume_set_id,128);
if (strlen(tmpstr)>0) printf("Volume set id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.publisher_id,128);
if (strlen(tmpstr)>0) printf("Publisher id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.preparer_id,128);
if (strlen(tmpstr)>0) printf("Preparer id: %s\n",tmpstr);
ISOGETSTR(tmpstr,ipd.application_id,128);
if (strlen(tmpstr)>0) printf("Application id: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.creation_date);
printf("Creation date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.modification_date);
if (!NULLISODATE(ipd.modification_date))
printf("Modification date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.expiration_date);
if (!NULLISODATE(ipd.expiration_date))
printf("Expiration date: %s\n",tmpstr);
ISOGETDATE(tmpstr,ipd.effective_date);
if (!NULLISODATE(ipd.effective_date))
printf("Effective date: %s\n",tmpstr);
printf("Image size: %02d:%02d:%02d, %d blocks (%ld bytes)\n",
LBA_MIN(ISONUM(ipd.volume_space_size)),
LBA_SEC(ISONUM(ipd.volume_space_size)),
LBA_FRM(ISONUM(ipd.volume_space_size)),
ISONUM(ipd.volume_space_size),
(long)ISONUM(ipd.volume_space_size)*BLOCKSIZE
);
printf("Track size: %02d:%02d:%02d, %d blocks (%ld bytes)\n",
LBA_MIN(tracksize),
LBA_SEC(tracksize),
LBA_FRM(tracksize),
tracksize,
(long)tracksize*BLOCKSIZE
);
}
} else {
#ifdef IRIX
/* if reading audio track */
imagesize=tracksize;
imagesize_bytes=imagesize*CDDA_DATASIZE;
buffersize = READBLOCKS*AUDIOBLOCKSIZE;
readblocksize = AUDIOBLOCKSIZE;
if (cdp) {
CDaddcallback(cdp, cd_audio, (CDCALLBACKFUNC)playaudio, 0);
} else die("No audioparser");
fclose(outfile);
aiffsetup=AFnewfilesetup();
AFinitrate(aiffsetup,AF_DEFAULT_TRACK,44100.0); /* 44.1 kHz */
AFinitfilefmt(aiffsetup,file_format); /* set file format */
AFinitchannels(aiffsetup,AF_DEFAULT_TRACK,2); /* stereo */
AFinitsampfmt(aiffsetup,AF_DEFAULT_TRACK,
AF_SAMPFMT_TWOSCOMP,16); /* 16bit */
aiffoutfile=AFopenfile(argv[optind],"w",aiffsetup);
if (!aiffoutfile) die("Cannot open target file (%s).",argv[optind]);
#endif
}
/* read the image */
if (md5_mode) MD5Init(MD5);
if (!info_only) {
start_time=(int)time(NULL);
fprintf(stderr,"Reading %s (%ldMb)...\n",
audio_track?"audio track":"ISO9660 image",
imagesize_bytes/(1024*1024));
do {
len=buffersize;
if(readsize/readblocksize+READBLOCKS>imagesize) {
read_10(start+counter,imagesize-readsize/readblocksize,buffer,&len);
}
else
read_10(start+counter,READBLOCKS,buffer,&len);
if ((counter%(1024*1024/readblocksize))<READBLOCKS) {
cur_time=(int)time(NULL);
if ((cur_time-start_time)>0) {
kbps=(readsize/1024)/(cur_time-start_time);
} else {
kbps=0;
}
fprintf(stderr,"%3dM of %dM read. (%d kb/s) \r",
counter/512,imagesize/512,kbps);
}
counter+=READBLOCKS;
readsize+=len;
if (!audio_track) {
fwrite(buffer,len,1,outfile);
} else {
#ifdef IRIX
/* audio track */
for(i=0;i<(len/CDDA_BLOCKSIZE);i++) {
CDparseframe(cdp,(CDFRAME*)&buffer[i*CDDA_BLOCKSIZE]);
}
#endif
}
if (md5_mode) MD5Update(MD5,buffer,(readsize>imagesize_bytes?
len-(readsize-imagesize_bytes):len) );
} while (len==readblocksize*READBLOCKS&&readsize<imagesize*readblocksize);
fprintf(stderr,"\n");
if (!audio_track) {
if (readsize > imagesize_bytes)
ftruncate(fileno(outfile),imagesize_bytes);
if (readsize < imagesize_bytes)
fprintf(stderr,"Image not complete!\n");
else fprintf(stderr,"Image complete.\n");
fclose(outfile);
} else {
#ifdef IRIX
AFclosefile(aiffoutfile);
#endif
}
}
if (md5_mode && !info_only) {
MD5Final((unsigned char*)digest,MD5);
md2str((unsigned char*)digest,digest_text);
fprintf(stderr,"MD5 (%s) = %s\n",(md5_mode==2?"'image'":argv[optind]),
digest_text);
}
quit:
start_stop(0);
/* set_removable(1); */
/* close the scsi device */
scsi_close();
return 0;
}
