static void
import_mbox_add_message (CamelFolder *folder,
CamelMimeMessage *msg,
GCancellable *cancellable,
GError **error)
{
CamelMessageInfo *info;
CamelMedium *medium;
guint32 flags = 0;
const gchar *tmp;
g_return_if_fail (CAMEL_IS_FOLDER (folder));
g_return_if_fail (CAMEL_IS_MIME_MESSAGE (msg));
medium = CAMEL_MEDIUM (msg);
tmp = camel_medium_get_header (medium, "X-Mozilla-Status");
if (tmp)
flags |= decode_mozilla_status (tmp);
tmp = camel_medium_get_header (medium, "Status");
if (tmp)
flags |= decode_status (tmp);
tmp = camel_medium_get_header (medium, "X-Status");
if (tmp)
flags |= decode_status (tmp);
info = camel_message_info_new (NULL);
camel_message_info_set_flags (info, flags, ~0);
camel_folder_append_message_sync (
folder, msg, info, NULL,
cancellable, error);
camel_message_info_unref (info);
}
static void capacitycomplete (void *iopexv, uLong status)
{
Devex *devex;
Iopex *iopex;
uLong sts;
uQuad totalmegs;
iopex = iopexv;
devex = iopex -> devex;
sts = decode_status (status, iopex, "reading capacity");
if ((sts == OZ_SUCCESS) && (iopex -> capacityrlen != sizeof iopex -> capacitybuff)) {
sts = OZ_IOFAILED;
oz_knl_printk ("oz_dev_exb8500: only read %u of %u bytes of %s capacity\n",
iopex -> capacityrlen, sizeof iopex -> capacitybuff, devex -> name);
}
if (sts == OZ_SUCCESS) {
devex -> blocksize = BUF2LONG (iopex -> capacitybuff + 4);
if ((devex -> blocksize == 0) || (devex -> blocksize > (1 << OZ_HW_L2PAGESIZE))) {
oz_knl_printk ("oz_dev_exb8500: %s blocksize %u invalid\n", devex -> name, devex -> blocksize);
sts = OZ_BADBLOCKSIZE;
} else {
devex -> valid = 1;
}
} else if (-- (iopex -> retries) >= 0) {
startreadcap (iopex);
return;
}
oz_dev_lio_done (iopex -> lior, sts, NULL, NULL);
}
static void skipcomplete (void *iopexv, uLong status)
{
Iopex *iopex;
uLong sts;
iopex = iopexv;
sts = decode_status (status, iopex, "skipping");
??
static void recv_metadata(grpc_call *call, grpc_metadata_batch *md) {
grpc_linked_mdelem *l;
grpc_metadata_array *dest;
grpc_metadata *mdusr;
int is_trailing;
grpc_mdctx *mdctx = call->metadata_context;
is_trailing = call->read_state >= READ_STATE_GOT_INITIAL_METADATA;
for (l = md->list.head; l != NULL; l = l->next) {
grpc_mdelem *md = l->md;
grpc_mdstr *key = md->key;
if (key == grpc_channel_get_status_string(call->channel)) {
set_status_code(call, STATUS_FROM_WIRE, decode_status(md));
} else if (key == grpc_channel_get_message_string(call->channel)) {
set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));
} else {
dest = &call->buffered_metadata[is_trailing];
if (dest->count == dest->capacity) {
dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);
dest->metadata =
gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);
}
mdusr = &dest->metadata[dest->count++];
mdusr->key = grpc_mdstr_as_c_string(md->key);
mdusr->value = grpc_mdstr_as_c_string(md->value);
mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);
if (call->owned_metadata_count == call->owned_metadata_capacity) {
call->owned_metadata_capacity =
GPR_MAX(call->owned_metadata_capacity + 8,
call->owned_metadata_capacity * 2);
call->owned_metadata =
gpr_realloc(call->owned_metadata,
sizeof(grpc_mdelem *) * call->owned_metadata_capacity);
}
call->owned_metadata[call->owned_metadata_count++] = md;
l->md = 0;
}
}
if (gpr_time_cmp(md->deadline, gpr_inf_future) != 0) {
set_deadline_alarm(call, md->deadline);
}
if (!is_trailing) {
call->read_state = READ_STATE_GOT_INITIAL_METADATA;
}
grpc_mdctx_lock(mdctx);
for (l = md->list.head; l; l = l->next) {
if (l->md) grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
}
for (l = md->garbage.head; l; l = l->next) {
grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
}
grpc_mdctx_unlock(mdctx);
}
static void rewindcomplete (void *iopexv, uLong status)
{
Iopex *iopex;
uLong sts;
iopex = iopexv;
sts = decode_status (status, iopex, "rewinding");
oz_dev_lio_done (iopex -> lior, sts, NULL, NULL);
}
static grpc_mdelem *recv_common_filter(grpc_call *call, grpc_mdelem *elem) {
if (elem->key == grpc_channel_get_status_string(call->channel)) {
GPR_TIMER_BEGIN("status", 0);
set_status_code(call, STATUS_FROM_WIRE, decode_status(elem));
GPR_TIMER_END("status", 0);
return NULL;
} else if (elem->key == grpc_channel_get_message_string(call->channel)) {
GPR_TIMER_BEGIN("status-details", 0);
set_status_details(call, STATUS_FROM_WIRE, GRPC_MDSTR_REF(elem->value));
GPR_TIMER_END("status-details", 0);
return NULL;
}
return elem;
}
static void completedrw (void *iopexv, uLong status)
{
Iopex *iopex;
uLong sts;
iopex = iopexv;
sts = decode_status (status, iopex, iopex -> writing ? "writing" : "reading");
if ((sts == OZ_SUCCESS) && iopex -> writing && (iopex -> datarlen != iopex -> datasize)) {
oz_knl_printk ("oz_dev_tape_scsi completedrw: only wrote %u bytes instead of %u\n", iopex -> datarlen, iopex -> datasize);
sts = OZ_IOFAILED;
}
oz_dev_lio_done (iopex -> lior, sts, (!(iopex -> writing) && (iopex -> callerrlen != NULL)) ? storerlen : NULL, iopex);
}
static void completedrw (void *iopexv, uLong status)
{
Iopex *iopex;
uLong sts;
iopex = iopexv;
sts = decode_status (status, iopex, iopex -> writing ? "writing" : "reading");
if ((sts == OZ_SUCCESS) && (iopex -> datarlen != iopex -> datasize)) {
oz_knl_printk ("oz_dev_disk_scsi completedrw: only %s %u bytes instead of %u\n",
iopex -> writing ? "wrote" : "read", iopex -> datarlen, iopex -> datasize);
sts = OZ_IOFAILED;
}
oz_dev_lio_done (iopex -> lior, sts, NULL, NULL);
}
static void validcomplete (void *iopexv, uLong status)
{
Devex *devex;
Iopex *iopex;
OZ_IO_scsi_doio scsi_doio;
uByte cmdbuf[6];
uLong sts;
iopex = iopexv;
devex = iopex -> devex;
sts = decode_status (status, iopex, iopex -> startstop ? "spinning up" : "spinning down");
if (iopex -> startstop) {
if (sts == OZ_SUCCESS) {
/* Drive is all spun up, read its capacity (also perform width/speed negotiation) */
startreadcap (iopex);
return;
}
if (-- (iopex -> retries) >= 0) {
cmdbuf[0] = 0x1B;
cmdbuf[1] = 0;
cmdbuf[2] = 0;
cmdbuf[3] = 0;
cmdbuf[4] = 1;
cmdbuf[5] = 0;
memset (&scsi_doio, 0, sizeof scsi_doio);
scsi_doio.cmdlen = sizeof cmdbuf;
scsi_doio.cmdbuf = cmdbuf;
scsi_doio.status = &(iopex -> scsists);
scsi_doio.optflags = OZ_IO_SCSI_OPTFLAG_DISCONNECT;
scsi_doio.timeout = IOTIMEOUT;
/* Queue the START STOP UNIT request to the scsi controller */
scsiio (iopex, iopex -> procmode, validcomplete, OZ_IO_SCSI_DOIO, sizeof scsi_doio, &scsi_doio);
return;
}
}
oz_dev_lio_done (iopex -> lior, sts, NULL, NULL);
}
static void validcomplete (void *iopexv, uLong status)
{
Devex *devex;
Iopex *iopex;
uLong sts;
iopex = iopexv;
devex = iopex -> devex;
sts = decode_status (status, iopex, iopex -> startstop ? "loading" : "unloading");
if ((sts == OZ_SUCCESS) && iopex -> startstop) {
/* Media is online, read all about it */
startreadcap (iopex);
return;
}
oz_dev_lio_done (iopex -> lior, sts, NULL, NULL);
}
static void capacitycomplete (void *iopexv, uLong status)
{
Devex *devex;
Iopex *iopex;
uLong sts;
uQuad totalmegs;
iopex = iopexv;
devex = iopex -> devex;
sts = decode_status (status, iopex, "reading capacity");
if ((sts == OZ_SUCCESS) && (iopex -> capacityrlen != sizeof iopex -> capacitybuff)) {
sts = OZ_IOFAILED;
oz_knl_printk ("oz_dev_scsi_disk: only read %u of %u bytes of %s capacity\n",
iopex -> capacityrlen, sizeof iopex -> capacitybuff, devex -> name);
}
if (sts == OZ_SUCCESS) {
devex -> totalblocks = BUF2LONG (iopex -> capacitybuff + 0);
devex -> blocksize = BUF2LONG (iopex -> capacitybuff + 4);
if (devex -> blocksize == 2352) {
oz_knl_printk ("oz_dev_scsi_disk: %s reports blocksize 2352, but using 2048\n", devex -> name);
devex -> blocksize = 2048; // hack for some CDROM drives that report audio block size
}
if ((devex -> blocksize == 0) || (devex -> blocksize > (1 << OZ_HW_L2PAGESIZE)) || (((1 << OZ_HW_L2PAGESIZE) % devex -> blocksize) != 0)) {
oz_knl_printk ("oz_dev_scsi_disk: %s blocksize %u invalid\n", devex -> name, devex -> blocksize);
sts = OZ_BADBLOCKSIZE;
} else {
totalmegs = ((uQuad)(devex -> totalblocks)) * ((uQuad)(devex -> blocksize));
totalmegs >>= 20;
oz_knl_printk ("oz_dev_scsi_disk: %s has %u blocks of %u bytes (%u Meg)\n",
devex -> name, devex -> totalblocks, devex -> blocksize, (uLong)totalmegs);
memset (&(devex -> scsi_getinfo1), 0, sizeof devex -> scsi_getinfo1);
scsiio (iopex, OZ_PROCMODE_KNL, getinfo1complete, OZ_IO_SCSI_GETINFO1,
sizeof devex -> scsi_getinfo1, &(devex -> scsi_getinfo1));
return;
}
} else if (-- (iopex -> retries) >= 0) {
void grpc_call_recv_metadata(grpc_call_element *elem, grpc_mdelem *md) {
grpc_call *call = CALL_FROM_TOP_ELEM(elem);
grpc_mdstr *key = md->key;
grpc_metadata_array *dest;
grpc_metadata *mdusr;
lock(call);
if (key == grpc_channel_get_status_string(call->channel)) {
set_status_code(call, STATUS_FROM_WIRE, decode_status(md));
grpc_mdelem_unref(md);
} else if (key == grpc_channel_get_message_string(call->channel)) {
set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));
grpc_mdelem_unref(md);
} else {
dest = &call->buffered_metadata[call->read_state >=
READ_STATE_GOT_INITIAL_METADATA];
if (dest->count == dest->capacity) {
dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);
dest->metadata =
gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);
}
mdusr = &dest->metadata[dest->count++];
mdusr->key = grpc_mdstr_as_c_string(md->key);
mdusr->value = grpc_mdstr_as_c_string(md->value);
mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);
if (call->owned_metadata_count == call->owned_metadata_capacity) {
call->owned_metadata_capacity = GPR_MAX(
call->owned_metadata_capacity + 8, call->owned_metadata_capacity * 2);
call->owned_metadata =
gpr_realloc(call->owned_metadata,
sizeof(grpc_mdelem *) * call->owned_metadata_capacity);
}
call->owned_metadata[call->owned_metadata_count++] = md;
}
unlock(call);
}
void maca_isr(void) {
// print_packets("maca_isr");
maca_entry++;
if (bit_is_set(*MACA_STATUS, maca_status_ovr))
{ PRINTF("maca overrun\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_busy))
{ PRINTF("maca busy\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_crc))
{ PRINTF("maca crc error\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_to))
{ PRINTF("maca timeout\n\r"); }
if (data_indication_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_di);
dma_rx->length = *MACA_GETRXLVL - 2; /* packet length does not include FCS */
dma_rx->lqi = get_lqi();
dma_rx->rx_time = *MACA_TIMESTAMP;
/* check if received packet needs an ack */
if(dma_rx->data[1] & 0x20) {
/* this wait is necessary to auto-ack */
volatile uint32_t wait_clk;
wait_clk = *MACA_CLK + 200;
while(*MACA_CLK < wait_clk) { continue; }
}
if(maca_rx_callback != 0) { maca_rx_callback(dma_rx); }
add_to_rx(dma_rx);
dma_rx = 0;
}
if (filter_failed_irq()) {
PRINTF("maca filter failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_flt);
}
if (checksum_failed_irq()) {
PRINTF("maca checksum failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_crc);
}
if (softclock_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_sftclk);
}
if (poll_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_poll);
}
if(action_complete_irq()) {
/* PRINTF("maca action complete %d\n\r", get_field(*MACA_CONTROL,SEQUENCE)); */
if(last_post == TX_POST) {
tx_head->status = get_field(*MACA_STATUS,CODE);
if(maca_tx_callback != 0) { maca_tx_callback(tx_head); }
dma_tx = 0;
free_tx_head();
last_post = NO_POST;
}
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_acpl);
}
decode_status();
if (*MACA_IRQ != 0)
{ PRINTF("*MACA_IRQ %x\n\r", (unsigned int)*MACA_IRQ); }
if(tx_head != 0) {
post_tx();
} else {
post_receive();
}
}
static void
import_mbox_exec (struct _import_mbox_msg *m)
{
CamelFolder *folder;
CamelMimeParser *mp = NULL;
struct stat st;
int fd;
CamelMessageInfo *info;
if (g_stat(m->path, &st) == -1) {
g_warning("cannot find source file to import '%s': %s", m->path, g_strerror(errno));
return;
}
if (m->uri == NULL || m->uri[0] == 0)
folder = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_INBOX);
else
folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &m->base.ex);
if (folder == NULL)
return;
if (S_ISREG(st.st_mode)) {
CamelOperation *oldcancel = NULL;
fd = g_open(m->path, O_RDONLY|O_BINARY, 0);
if (fd == -1) {
g_warning("cannot find source file to import '%s': %s", m->path, g_strerror(errno));
goto fail1;
}
mp = camel_mime_parser_new();
camel_mime_parser_scan_from(mp, TRUE);
if (camel_mime_parser_init_with_fd(mp, fd) == -1) { /* will never happen - 0 is unconditionally returned */
goto fail2;
}
if (m->cancel)
oldcancel = camel_operation_register(m->cancel);
camel_operation_start(NULL, _("Importing `%s'"), folder->full_name);
camel_folder_freeze(folder);
while (camel_mime_parser_step(mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM) {
CamelMimeMessage *msg;
const char *tmp;
int pc = 0;
guint32 flags = 0;
if (st.st_size > 0)
pc = (int)(100.0 * ((double)camel_mime_parser_tell(mp) / (double)st.st_size));
camel_operation_progress(NULL, pc);
msg = camel_mime_message_new();
if (camel_mime_part_construct_from_parser((CamelMimePart *)msg, mp) == -1) {
/* set exception? */
camel_object_unref(msg);
break;
}
info = camel_message_info_new(NULL);
tmp = camel_medium_get_header((CamelMedium *)msg, "X-Mozilla-Status");
if (tmp)
flags |= decode_mozilla_status(tmp);
tmp = camel_medium_get_header((CamelMedium *)msg, "Status");
if (tmp)
flags |= decode_status(tmp);
tmp = camel_medium_get_header((CamelMedium *)msg, "X-Status");
if (tmp)
flags |= decode_status(tmp);
camel_message_info_set_flags(info, flags, ~0);
camel_folder_append_message(folder, msg, info, NULL, &m->base.ex);
camel_message_info_free(info);
camel_object_unref(msg);
if (camel_exception_is_set(&m->base.ex))
break;
camel_mime_parser_step(mp, NULL, NULL);
}
camel_folder_sync(folder, FALSE, NULL);
camel_folder_thaw(folder);
camel_operation_end(NULL);
/* TODO: these api's are a bit weird, registering the old is the same as deregistering */
if (m->cancel)
camel_operation_register(oldcancel);
fail2:
camel_object_unref(mp);
}
fail1:
camel_folder_sync(folder, FALSE, NULL);
camel_object_unref(folder);
}
void maca_isr(void) {
// print_packets("maca_isr");
maca_entry++;
if (bit_is_set(*MACA_STATUS, maca_status_ovr))
{ PRINTF("maca overrun\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_busy))
{ PRINTF("maca busy\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_crc))
{ PRINTF("maca crc error\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_to))
{ PRINTF("maca timeout\n\r"); }
if (data_indication_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_di);
dma_rx->length = *MACA_GETRXLVL - 2; /* packet length does not include FCS */
// PRINTF("maca data ind %x %d\n\r", dma_rx, dma_rx->length);
if(maca_rx_callback != 0) { maca_rx_callback(dma_rx); }
add_to_rx(dma_rx);
dma_rx = 0;
}
if (filter_failed_irq()) {
PRINTF("maca filter failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_flt);
}
if (checksum_failed_irq()) {
PRINTF("maca checksum failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_crc);
}
if (softclock_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_sftclk);
}
if (poll_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_poll);
}
if(action_complete_irq()) {
/* PRINTF("maca action complete %d\n\r", get_field(*MACA_CONTROL,SEQUENCE)); */
if(last_post == TX_POST) {
if(maca_tx_callback != 0) { maca_tx_callback(tx_head); }
dma_tx = 0;
free_tx_head();
last_post = NO_POST;
}
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_acpl);
}
decode_status();
if (*MACA_IRQ != 0)
{ PRINTF("*MACA_IRQ %x\n\r", *MACA_IRQ); }
if(tx_head != 0) {
post_tx();
} else {
post_receive();
}
}
void maca_isr(void) {
// print_packets("maca_isr");
maca_entry++;
if (bit_is_set(*MACA_STATUS, maca_status_ovr))
{ PRINTF("maca overrun\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_busy))
{ PRINTF("maca busy\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_crc))
{ PRINTF("maca crc error\n\r"); }
if (bit_is_set(*MACA_STATUS, maca_status_to))
{ PRINTF("maca timeout\n\r"); }
if (data_indication_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_di);
if (dma_rx != &dummy_ack && dma_rx != &dummy_rx)
{
dma_rx->length = *MACA_GETRXLVL - 2; /* packet length does not include FCS */
dma_rx->lqi = get_lqi();
dma_rx->rx_time = *MACA_TIMESTAMP;
/* check if received packet needs an ack */
if(prm_mode == AUTOACK && (dma_rx->data[1] & 0x20)) {
/* this wait is necessary to auto-ack */
volatile uint32_t wait_clk;
wait_clk = *MACA_CLK + 200;
while(*MACA_CLK < wait_clk) { continue; }
}
if(maca_rx_callback != 0) { maca_rx_callback(dma_rx); }
add_to_rx(dma_rx);
}
dma_rx = 0;
}
if (filter_failed_irq()) {
PRINTF("maca filter failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_flt);
}
if (checksum_failed_irq()) {
PRINTF("maca checksum failed\n\r");
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_crc);
}
if (softclock_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_sftclk);
}
if (poll_irq()) {
*MACA_CLRIRQ = (1 << maca_irq_poll);
}
if(action_complete_irq()) {
/* PRINTF("maca action complete %d\n\r", get_field(*MACA_CONTROL,SEQUENCE)); */
if(last_post == TX_POST) {
tx_head->status = get_field(*MACA_STATUS,CODE);
#if MACA_INSERT_ACK
/* Having sent a message with the acknowledge request flag set the
* MACA hardware will only give a tx success indication if the message
* was acknowledged by the remote node. We need to detect this
* condition and inject an ACK packet into the internal receive stream
* as the higher layers are expecting to see an ACK packet.*/
if(tx_head->status == SUCCESS && (tx_head->data[0] & MAC_ACK_REQUEST_FLAG)) {
/* Create the dummy ack packet */
static volatile packet_t *ack_p;
if(ack_p = get_free_packet()) {
ack_p->length = 3;
ack_p->offset = 1;
ack_p->data[0] = 3;
ack_p->data[1] = 0x02;
ack_p->data[2] = 0;
ack_p->data[3] = *MACA_TXSEQNR;
insert_at_rx_head(ack_p);
}
}
#endif
if(maca_tx_callback != 0) { maca_tx_callback(tx_head); }
dma_tx = 0;
free_tx_head();
last_post = NO_POST;
}
ResumeMACASync();
*MACA_CLRIRQ = (1 << maca_irq_acpl);
}
decode_status();
if (*MACA_IRQ != 0)
{ PRINTF("*MACA_IRQ %x\n\r", (unsigned int)*MACA_IRQ); }
if(tx_head != 0) {
post_tx();
} else {
post_receive();
}
}
int main(int argc, char * argv[])
{
int sg_fd, k, j, off, res, c, report_len, tgt_port_count;
unsigned char reportTgtGrpBuff[REPORT_TGT_GRP_BUFF_LEN];
unsigned char * ucp;
int decode = 0;
int hex = 0;
int raw = 0;
int o_readonly = 0;
int verbose = 0;
int extended = 0;
const char * device_name = NULL;
int ret = 0;
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "dehHrRvV", long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'd':
decode = 1;
break;
case 'e':
extended = 1;
break;
case 'h':
case '?':
usage();
return 0;
case 'H':
hex = 1;
break;
case 'r':
raw = 1;
break;
case 'R':
++o_readonly;
break;
case 'v':
++verbose;
break;
case 'V':
fprintf(stderr, "Version: %s\n", version_str);
return 0;
default:
fprintf(stderr, "unrecognised option code 0x%x ??\n", c);
usage();
return SG_LIB_SYNTAX_ERROR;
}
}
if (optind < argc) {
if (NULL == device_name) {
device_name = argv[optind];
++optind;
}
if (optind < argc) {
for (; optind < argc; ++optind)
fprintf(stderr, "Unexpected extra argument: %s\n",
argv[optind]);
usage();
return SG_LIB_SYNTAX_ERROR;
}
}
if (NULL == device_name) {
fprintf(stderr, "missing device name!\n");
usage();
return SG_LIB_SYNTAX_ERROR;
}
if (raw) {
if (sg_set_binary_mode(STDOUT_FILENO) < 0) {
perror("sg_set_binary_mode");
return SG_LIB_FILE_ERROR;
}
}
sg_fd = sg_cmds_open_device(device_name, o_readonly, verbose);
if (sg_fd < 0) {
fprintf(stderr, "open error: %s: %s\n", device_name,
safe_strerror(-sg_fd));
return SG_LIB_FILE_ERROR;
}
memset(reportTgtGrpBuff, 0x0, sizeof(reportTgtGrpBuff));
/* trunc = 0; */
res = sg_ll_report_tgt_prt_grp2(sg_fd, reportTgtGrpBuff,
sizeof(reportTgtGrpBuff),
extended, 1, verbose);
ret = res;
if (0 == res) {
report_len = (reportTgtGrpBuff[0] << 24) +
(reportTgtGrpBuff[1] << 16) +
(reportTgtGrpBuff[2] << 8) +
reportTgtGrpBuff[3] + 4;
if (report_len > (int)sizeof(reportTgtGrpBuff)) {
/* trunc = 1; */
fprintf(stderr, " <<report too long for internal buffer,"
" output truncated\n");
report_len = (int)sizeof(reportTgtGrpBuff);
}
if (raw) {
dStrRaw((const char *)reportTgtGrpBuff, report_len);
goto err_out;
}
if (verbose)
printf("Report list length = %d\n", report_len);
if (hex) {
if (verbose)
printf("\nOutput response in hex:\n");
dStrHex((const char *)reportTgtGrpBuff, report_len, 1);
goto err_out;
}
printf("Report target port groups:\n");
ucp = reportTgtGrpBuff + 4;
if (extended) {
if (0x10 != (ucp[0] & 0x70)) {
fprintf(stderr, " <<invalid extended header format\n");
goto err_out;
}
printf(" Implicit transition time: %d\n", ucp[1]);
ucp += 4;
}
for (k = ucp - reportTgtGrpBuff; k < report_len;
k += off, ucp += off) {
printf(" target port group id : 0x%x , Pref=%d, Rtpg_fmt=%d\n",
(ucp[2] << 8) + ucp[3], !!(ucp[0] & 0x80),
(ucp[0] >> 4) & 0x07);
printf(" target port group asymmetric access state : ");
printf("0x%02x", ucp[0] & 0x0f);
if (decode)
decode_tpgs_state(ucp[0] & 0x0f);
printf("\n");
printf(" T_SUP : %d, ", !!(ucp[1] & 0x80));
printf("O_SUP : %d, ", !!(ucp[1] & 0x40));
printf("LBD_SUP : %d, ", !!(ucp[1] & 0x10));
printf("U_SUP : %d, ", !!(ucp[1] & 0x08));
printf("S_SUP : %d, ", !!(ucp[1] & 0x04));
printf("AN_SUP : %d, ", !!(ucp[1] & 0x02));
printf("AO_SUP : %d\n", !!(ucp[1] & 0x01));
printf(" status code : ");
printf("0x%02x", ucp[5]);
if (decode)
decode_status(ucp[5]);
printf("\n");
printf(" vendor unique status : ");
printf("0x%02x\n", ucp[6]);
printf(" target port count : ");
tgt_port_count = ucp[7];
printf("%02x\n", tgt_port_count);
for (j = 0; j < tgt_port_count * 4; j += 4) {
if (0 == j)
printf(" Relative target port ids:\n");
printf(" 0x%02x\n",
(ucp[8 + j + 2] << 8) + ucp[8 + j + 3]);
}
off = 8 + j;
}
} else if (SG_LIB_CAT_INVALID_OP == res)
