signed ModuleDump (struct plc * plc, uint16_t source, uint16_t module, uint16_t submodule)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_module_operation_read_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t RESERVED;
uint8_t NUM_OP_DATA;
struct __packed
{
uint16_t MOD_OP;
uint16_t MOD_OP_DATA_LEN;
uint32_t MOD_OP_RSVD;
uint16_t MODULE_ID;
uint16_t MODULE_SUB_ID;
uint16_t MODULE_LENGTH;
uint32_t MODULE_OFFSET;
}
MODULE_SPEC;
}
* request = (struct vs_module_operation_read_request *)(message);
struct __packed vs_module_operation_read_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint16_t MSTATUS;
uint16_t ERR_REC_CODE;
uint32_t RESERVED;
uint8_t NUM_OP_DATA;
struct __packed
{
uint16_t MOD_OP;
uint16_t MOD_OP_DATA_LEN;
uint32_t MOD_OP_RSVD;
uint16_t MODULE_ID;
uint16_t MODULE_SUB_ID;
uint16_t MODULE_LENGTH;
uint32_t MODULE_OFFSET;
}
MODULE_SPEC;
uint8_t MODULE_DATA [PLC_MODULE_SIZE];
}
* confirm = (struct vs_module_operation_read_confirm *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
unsigned offset = 0;
unsigned length = PLC_MODULE_SIZE;
unsigned timer = channel->timeout;
Request (plc, "Read Module from Flash");
while (length == PLC_MODULE_SIZE)
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_MODULE_OPERATION | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->NUM_OP_DATA = 1;
request->MODULE_SPEC.MOD_OP = HTOLE16 (source);
request->MODULE_SPEC.MOD_OP_DATA_LEN = HTOLE16 (sizeof (request->MODULE_SPEC));
request->MODULE_SPEC.MOD_OP_RSVD = HTOLE32 (0);
request->MODULE_SPEC.MODULE_ID = HTOLE16 (module);
request->MODULE_SPEC.MODULE_SUB_ID = HTOLE16 (submodule);
request->MODULE_SPEC.MODULE_LENGTH = HTOLE16 (length);
request->MODULE_SPEC.MODULE_OFFSET = HTOLE32 (offset);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
channel->timeout = PLC_MODULE_READ_TIMEOUT;
if (ReadMME (plc, 0, (VS_MODULE_OPERATION | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
channel->timeout = timer;
return (-1);
}
channel->timeout = timer;
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
length = LE16TOH (confirm->MODULE_SPEC.MODULE_LENGTH);
offset = LE32TOH (confirm->MODULE_SPEC.MODULE_OFFSET);
hexview (confirm->MODULE_DATA, LE32TOH (confirm->MODULE_SPEC.MODULE_OFFSET), LE16TOH (confirm->MODULE_SPEC.MODULE_LENGTH), stdout);
offset += length;
}
return (0);
}
static void function (file const * file, off_t extent, flag_t flags)
{
unsigned object = 0;
unsigned lineno = 0;
unsigned offset = 0;
unsigned length = 0;
char memory [_ADDRSIZE + 1];
char symbol [_NAMESIZE];
char string [_LINESIZE];
char * sp;
signed c;
while ((c = getc (stdin)) != EOF)
{
if ((c == '#') || (c == ';'))
{
do
{
c = getc (stdin);
}
while (nobreak (c));
lineno++;
continue;
}
if (isspace (c))
{
if (c == '\n')
{
lineno++;
}
continue;
}
length = 0;
while (isdigit (c))
{
length *= 10;
length += c - '0';
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
sp = symbol;
if (isalpha (c) || (c == '_'))
{
do
{
* sp++ = (char) (c);
c = getc (stdin);
}
while (isident (c));
}
while (isblank (c))
{
c = getc (stdin);
}
if (c == '[')
{
* sp++ = (char) (c);
c = getc (stdin);
while (isblank (c))
{
c = getc (stdin);
}
while (isdigit (c))
{
* sp++ = (char) (c);
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
* sp = (char) (0);
if (c != ']')
{
error (1, EINVAL, "Have '%s' without ']' on line %d", symbol, lineno);
}
* sp++ = (char) (c);
c = getc (stdin);
}
* sp = (char) (0);
while (isblank (c))
{
c = getc (stdin);
}
sp = string;
while (nobreak (c))
{
* sp++ = (char) (c);
c = getc (stdin);
}
* sp = (char) (0);
if (length)
{
byte buffer [length];
if (read (file->file, buffer, length) == (signed) (length))
{
if (! object++)
{
for (c = 0; c < _ADDRSIZE + 65; c++)
{
putc ('-', stdout);
}
putc ('\n', stdout);
}
printf ("%s %u %s\n", hexoffset (memory, sizeof (memory), offset), length, symbol);
hexview (buffer, offset, length, stdout);
for (c = 0; c < _ADDRSIZE + 65; c++)
{
putc ('-', stdout);
}
putc ('\n', stdout);
}
}
offset += length;
lineno++;
}
if (_allclr (flags, ODD_SILENCE))
{
if (offset != (unsigned) (extent))
{
error (0, 0, "%s has %u bytes, not " OFF_T_SPEC " bytes.", file->name, offset, extent);
}
}
return;
}
static signed ReadVLANIDs (struct plc * plc, uint32_t offset, uint32_t length)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_forward_config_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t RESERVED1;
uint8_t MREQUEST;
uint8_t MVERSION;
uint32_t RESERVED2;
uint32_t DATA_LENGTH;
uint32_t DATA_OFFSET;
uint16_t RESERVED3;
}
* request = (struct vs_forward_config_request *) (message);
struct __packed vs_forward_config_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t RESERVED1;
uint8_t RESULTCODE;
uint8_t OPERATION;
uint8_t MVERSION;
uint32_t RESERVED2;
uint32_t DATA_LENGTH;
uint32_t DATA_OFFSET;
uint8_t DATA [PLC_MODULE_SIZE];
}
* confirm = (struct vs_forward_config_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
request->MREQUEST = PLCFWD_GET;
request->MVERSION = PLCFWD_VER;
request->DATA_OFFSET = HTOLE32 (offset);
request->DATA_LENGTH = HTOLE32 (length);
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) > 0)
{
if (confirm->RESULTCODE)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
hexview (confirm->DATA, LE32TOH (confirm->DATA_OFFSET), LE32TOH (confirm->DATA_LENGTH), stdout);
}
return (0);
}
