static signed pibchain2 (void const * memory, char const * filename, flag_t flags)
{
struct nvm_header2 * nvm_header;
size_t origin = ~0;
size_t offset = 0;
signed module = 0;
do
{
nvm_header = (struct nvm_header2 *)((char *)(memory) + offset);
if (LE16TOH (nvm_header->MajorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE16TOH (nvm_header->MinorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE32TOH (nvm_header->PrevHeader) != origin)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
return (-1);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
error (0, 0, NVM_HDR_CHECKSUM, filename, module);
return (-1);
}
origin = offset;
offset += sizeof (* nvm_header);
if (LE32TOH (nvm_header->ImageType) == NVM_IMAGE_PIB)
{
pibpeek2 ((char *)(memory) + offset);
break;
}
if (checksum32 ((char *)(memory) + offset, LE32TOH (nvm_header->ImageLength), nvm_header->ImageChecksum))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_IMG_CHECKSUM, filename, module);
}
return (-1);
}
offset += LE32TOH (nvm_header->ImageLength);
module++;
}
while (~nvm_header->NextHeader);
return (0);
}
signed pibfile (struct _file_ * pib)
{
struct simple_pib simple_pib;
if (lseek (pib->file, 0, SEEK_SET))
{
error (1, errno, "Can't rewind %s", pib->name);
}
if (read (pib->file, &simple_pib, sizeof (simple_pib)) < sizeof (simple_pib))
{
error (1, errno, "Can't read header: %s", pib->name);
}
if (lseek (pib->file, 0, SEEK_END) != LE16TOH (simple_pib.PIBLENGTH))
{
error (1, errno, "Bad PIB length: %s", pib->name);
}
if (lseek (pib->file, 0, SEEK_SET))
{
error (1, errno, "Can't rewind %s", pib->name);
}
if (fdchecksum_32 (pib->file, LE16TOH (simple_pib.PIBLENGTH), 0))
{
error (1, errno, "Bad PIB checksum: %s", pib->name);
}
if (lseek (pib->file, 0, SEEK_SET))
{
error (1, errno, "Can't rewind %s", pib->name);
}
return (0);
}
int
spca50x_flash_get_filecount (CameraPrivateLibrary *pl, int *filecount)
{
uint16_t response = 0;
if (pl->bridge == BRIDGE_SPCA500) { /* dsc350 cams */
return spca50x_flash_get_TOC (pl, filecount);
} else {
if (pl->fw_rev == 1) {
CHECK (gp_port_usb_msg_read (pl->gpdev,
0x0b, 0x0000, 0x0000,
(char*)&response, 0x02));
/* Each file gets two toc entries, one for the
image, one for the thumbnail */
LE16TOH (response);
*filecount = response/2;
} else {
CHECK (gp_port_usb_msg_read (pl->gpdev,
0x54, 0x0000, 0x0000,
(char*)&response, 0x02));
LE16TOH (response);
*filecount = response;
}
}
return GP_OK;
}
signed pibfile2 (struct _file_ const * file)
{
struct nvm_header2 nvm_header;
uint32_t origin = ~0;
uint32_t offset = 0;
unsigned module = 0;
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
do
{
if (read (file->file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTREAD, file->name, module);
}
if (LE16TOH (nvm_header.MajorVersion) != 1)
{
error (1, errno, NVM_HDR_VERSION, file->name, module);
}
if (LE16TOH (nvm_header.MinorVersion) != 1)
{
error (1, errno, NVM_HDR_VERSION, file->name, module);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
error (1, errno, NVM_HDR_CHECKSUM, file->name, module);
}
if (LE32TOH (nvm_header.PrevHeader) != origin)
{
error (1, errno, NVM_HDR_LINK, file->name, module);
}
if (LE32TOH (nvm_header.ImageType) == NVM_IMAGE_PIB)
{
if (fdchecksum32 (file->file, LE32TOH (nvm_header.ImageLength), nvm_header.ImageChecksum))
{
error (1, errno, NVM_IMG_CHECKSUM, file->name, module);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
return (0);
}
if (fdchecksum32 (file->file, LE32TOH (nvm_header.ImageLength), nvm_header.ImageChecksum))
{
error (1, errno, NVM_IMG_CHECKSUM, file->name, module);
}
origin = offset;
offset = LE32TOH (nvm_header.NextHeader);
module++;
}
while (~nvm_header.NextHeader);
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
return (-1);
}
signed BootParameters2 (struct plc * plc)
{
unsigned module = 0;
struct nvm_header2 nvm_header;
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
do
{
if (read (plc->PIB.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTREAD, plc->PIB.name, module);
}
if (LE16TOH (nvm_header.MajorVersion) != 1)
{
error (1, ECANCELED, NVM_HDR_VERSION, plc->PIB.name, module);
}
if (LE16TOH (nvm_header.MinorVersion) != 1)
{
error (1, ECANCELED, NVM_HDR_VERSION, plc->PIB.name, module);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
error (1, ECANCELED, NVM_HDR_CHECKSUM, plc->PIB.name, module);
}
#if 0
if (_allclr (LE16TOH (nvm_header.ExecuteMask), (1 << (plc->hardwareID - 1))))
{
if (lseek (plc->PIB.file, LE32TOH (nvm_header.NextHeader), SEEK_SET) == -1)
{
error (1, errno, "Can't skip module: %s (%d)", plc->PIB.name, module);
}
}
else
#endif
if (LE32TOH (nvm_header.ImageType) == NVM_IMAGE_PIB)
{
if (WriteExecuteParameters2 (plc, module, &nvm_header))
{
return (-1);
}
break;
}
if (lseek (plc->PIB.file, LE32TOH (nvm_header.NextHeader), SEEK_SET) == -1)
{
error (1, errno, "Can't skip module: %s (%d)", plc->PIB.name, module);
}
module++;
}
while (~nvm_header.NextHeader);
return (0);
}
static signed pibedit2 (char const * filename, struct node const * node, char * memory, size_t extent)
{
struct nvm_header2 * nvm_header;
uint32_t origin = ~0;
uint32_t offset = 0;
unsigned length = 0;
unsigned module = 0;
do
{
nvm_header = (struct nvm_header2 *)(memory + offset);
if (LE16TOH (nvm_header->MajorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, filename, module);
}
if (LE16TOH (nvm_header->MinorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, filename, module);
}
if (LE32TOH (nvm_header->PrevHeader) != origin)
{
error (1, 0, NVM_HDR_LINK, filename, module);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
error (1, 0, NVM_HDR_CHECKSUM, filename, module);
}
origin = offset;
offset += sizeof (* nvm_header);
extent -= sizeof (* nvm_header);
length = LE32TOH (nvm_header->ImageLength);
if (checksum32 (memory + offset, length, nvm_header->ImageChecksum))
{
error (1, 0, NVM_IMG_CHECKSUM, filename, module);
}
if (LE32TOH (nvm_header->ImageType) == NVM_IMAGE_PIB)
{
xmledit (node, memory + offset, length);
nvm_header->ImageChecksum = checksum32 (memory + offset, length, 0);
nvm_header->HeaderChecksum = checksum32 (nvm_header, sizeof (* nvm_header), nvm_header->HeaderChecksum);
return (0);
}
offset += length;
extent -= length;
module++;
}
while (~nvm_header->NextHeader);
return (-1);
}
static void function2 (struct _file_ * file, signed index, flag_t flags)
{
static signed image = 0;
static signed origin = ~0;
static signed offset = 0;
struct nvm_header2 nvm_header;
if (read (file->file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTREAD, file->name, image);
}
if (LE16TOH (nvm_header.MajorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, file->name, image);
}
if (LE16TOH (nvm_header.MinorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, file->name, image);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
error (1, 0, NVM_HDR_CHECKSUM, file->name, image);
}
if (~nvm_header.PrevHeader)
{
error (1, 0, NVM_HDR_LINK, file->name, image);
}
if (~nvm_header.NextHeader)
{
error (1, 0, NVM_HDR_LINK, file->name, image);
}
nvm_header.PrevHeader = HTOLE32 (origin);
origin = offset;
if (index)
{
offset += sizeof (nvm_header);
offset += LE32TOH (nvm_header.ImageLength);
nvm_header.NextHeader = HTOLE32 (offset);
}
nvm_header.HeaderChecksum = 0;
nvm_header.HeaderChecksum = checksum32 (&nvm_header, sizeof (nvm_header), 0);
if (write (STDOUT_FILENO, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTSAVE, file->name, image);
}
copyimage (file, LE32TOH (nvm_header.ImageLength), image);
image++;
return;
}
signed ar7x00_psin (struct _file_ * pib, uint32_t value, uint32_t index)
{
off_t offset = AMP_PRESCALER_OFFSET + (index * 10 / 8);
uint8_t bit_offset = (index * 10) % 8;
uint16_t tmp;
if (lseek (pib->file, offset, SEEK_SET) != offset)
{
return (-1);
}
if (read (pib->file, &tmp, sizeof (tmp)) != sizeof (tmp))
{
return (-1);
}
if (lseek (pib->file, offset, SEEK_SET) != offset)
{
return (-1);
}
value &= 0x03FF;
tmp = LE16TOH (tmp);
tmp &= ~(0x03FF << bit_offset);
tmp |= value << bit_offset;
tmp = HTOLE16 (tmp);
if (write (pib->file, &tmp, sizeof (tmp)) != sizeof (tmp))
{
return (-1);
}
return (0);
}
signed pibfile1 (struct _file_ const * file)
{
struct simple_pib simple_pib;
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
if (read (file->file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTREAD, file->name);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
if ((simple_pib.RESERVED1) || (simple_pib.RESERVED2))
{
error (1, errno, PIB_BADCONTENT, file->name);
}
if (fdchecksum32 (file->file, LE16TOH (simple_pib.PIBLENGTH), 0))
{
error (1, errno, PIB_BADCHECKSUM, file->name);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
return (0);
}
void nvmpeek1 (void const * memory)
{
extern char const * nvm_imagetypes [];
extern char const * nvm_platforms [];
struct nvm_header1 * nvm_header = (struct nvm_header1 *)(memory);
char const * string = "Unknown";
char platform [100];
printf ("\tHeader Version = 0x%08X-%02X\n", LE32TOH (nvm_header->HEADERVERSION), nvm_header->HEADERMINORVERSION);
printf ("\tHeader Checksum = 0x%08X\n", LE32TOH (nvm_header->HEADERCHECKSUM));
printf ("\tHeader Next = 0x%08X\n", LE32TOH (nvm_header->NEXTHEADER));
printf ("\tFlash Address = 0x%08X\n", LE32TOH (nvm_header->IMAGEROMADDR));
printf ("\tImage Address = 0x%08X\n", LE32TOH (nvm_header->IMAGEADDRESS));
printf ("\tEntry Address = 0x%08X\n", LE32TOH (nvm_header->ENTRYPOINT));
printf ("\tImage Checksum = 0x%08X\n", LE32TOH (nvm_header->IMAGECHECKSUM));
printf ("\tImage Size = 0x%08X (%d)\n", LE32TOH (nvm_header->IMAGELENGTH), LE32TOH (nvm_header->IMAGELENGTH));
if (LE32TOH (nvm_header->IMAGETYPE) < NVM_IMAGETYPES)
{
string = nvm_imagetypes [LE32TOH (nvm_header->IMAGETYPE)];
}
printf ("\tImage Type = %s\n", string);
strfbits (platform, sizeof (platform), nvm_platforms, "|", LE16TOH (nvm_header->IGNOREMASK));
printf ("\tImage Omit = %s\n", platform);
return;
}
signed piblock (struct _file_ const * file)
{
struct simple_pib simple_pib;
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, "1 " FILE_CANTHOME, file->name);
}
if (read (file->file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTREAD, file->name);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
simple_pib.CHECKSUM = fdchecksum32 (file->file, LE16TOH (simple_pib.PIBLENGTH), simple_pib.CHECKSUM);
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, "2 " FILE_CANTHOME, file->name);
}
if (write (file->file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTSAVE, file->name);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
return (0);
}
void nvmpeek2 (void const * memory)
{
extern char const * nvm_imagetypes [];
extern char const * nvm_platforms [];
struct nvm_header2 * nvm_header = (struct nvm_header2 *)(memory);
char const * string = "Unknown";
char platform [100];
printf ("\tHeader Version = 0x%04x-0x%04x\n", LE16TOH (nvm_header->MajorVersion), nvm_header->MinorVersion);
printf ("\tHeader Checksum = 0x%08X\n", LE32TOH (nvm_header->HeaderChecksum));
printf ("\tHeader Next = 0x%08X\n", LE32TOH (nvm_header->NextHeader));
printf ("\tHeader Prev = 0x%08X\n", LE32TOH (nvm_header->PrevHeader));
printf ("\tFlash Address = 0x%08X\n", LE32TOH (nvm_header->ImageNvmAddress));
printf ("\tImage Address = 0x%08X\n", LE32TOH (nvm_header->ImageAddress));
printf ("\tEntry Address = 0x%08X\n", LE32TOH (nvm_header->EntryPoint));
printf ("\tEntry Version = 0x%04X\n", LE16TOH (nvm_header->AppletEntryVersion));
printf ("\tImage Checksum = 0x%08X\n", LE32TOH (nvm_header->ImageChecksum));
printf ("\tImage ModuleID = 0x%04X\n", LE32TOH (nvm_header->ModuleID));
printf ("\tImage ModuleSubID = 0x%04X\n", LE32TOH (nvm_header->ModuleSubID));
printf ("\tImage Size = 0x%08X (%d)\n", LE32TOH (nvm_header->ImageLength), LE32TOH (nvm_header->ImageLength));
if (LE32TOH (nvm_header->ImageType) < NVM_IMAGETYPES)
{
string = nvm_imagetypes [LE32TOH (nvm_header->ImageType)];
}
printf ("\tImage Type = %s\n", string);
strfbits (platform, sizeof (platform), nvm_platforms, "|", LE16TOH (nvm_header->ExecuteMask));
printf ("\tImage Exec = %s\n", platform);
#if 0
printf ("\tReserved = 0x%04X\n", LE16TOH (nvm_header->Reserved0));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved1));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved2));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved3));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved4));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved5));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved6));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved7));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved8));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved9));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved10));
printf ("\tReserved = 0x%08X\n", LE32TOH (nvm_header->Reserved11));
#endif
return;
}
signed AutoConnection (struct auto_connection * auto_connection)
{
int i;
if (auto_connection->MACTION == ACTION_TAGTX)
{
printf ("-T 0x%08X -V %d ", ntohl (auto_connection->cspec.VLAN_TAG), LE16TOH (auto_connection->cspec.CSPEC_VERSION));
}
printf ("%s", reword (auto_connection->MACTION, actions, SIZEOF (actions)));
printf (" %s ", reword (auto_connection->MOPERAND, operands, SIZEOF (operands)));
for (i = 0; i < LE16TOH (auto_connection->NUM_CLASSIFIERS); ++i)
{
Classifier (&auto_connection->CLASSIFIER [i]);
putchar (' ');
}
printf ("add perm\n");
return (0);
}
signed BootParameters1 (struct plc * plc)
{
struct pib_header pib_header;
uint32_t offset;
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &pib_header, sizeof (pib_header)) != sizeof (pib_header))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTREAD, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTHOME, plc->PIB.name);
}
#if 1
/*
* this code is a fix to accommodate PIB relocation in memory; it is not needed when
* the PIB is stored in an NVM file since the memory address is recorded in the image
* header;
*/
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
#endif
if (plc->hardwareID < CHIPSET_AR7400)
{
if (WriteMEM (plc, &plc->PIB, 0, offset, LE16TOH (pib_header.PIBLENGTH)))
{
return (-1);
}
return (0);
}
if (WriteExecutePIB (plc, offset, &pib_header))
{
return (-1);
}
return (0);
}
/*
* Get the number of images in cam
*
* Status: Should work, but not used as enigma13_get_TOC does all.
*
*/
static int enigma13_get_filecount (Camera *camera, int *filecount)
{
uint16_t response = 0;
CHECK(enigma13_wait_for_ready(camera));
CHECK (gp_port_usb_msg_read (camera->port,
0x54, 0x0000, 0x0000,
(char*)&response, 0x02));
LE16TOH (response);
*filecount = response;
return GP_OK;
}
signed evse_cm_slac_match (struct session * session, struct channel * channel, struct message * message)
{
struct cm_slac_match_request * request = (struct cm_slac_match_request *) (message);
struct cm_slac_match_confirm * confirm = (struct cm_slac_match_confirm *) (message);
while (readmessage (channel, message, HOMEPLUG_MMV, (CM_SLAC_MATCH | MMTYPE_REQ)) > 0)
{
if (! memcmp (session->RunID, request->MatchVarField.RunID, sizeof (session->RunID)))
{
slac_debug (session, 0, __func__, "<-- CM_SLAC_MATCH.REQ");
memcpy (session->PEV_ID, request->MatchVarField.PEV_ID, sizeof (session->PEV_ID));
memcpy (session->PEV_MAC, request->MatchVarField.PEV_MAC, sizeof (session->PEV_MAC));
memcpy (session->RunID, request->MatchVarField.RunID, sizeof (session->RunID));
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.APPLICATION_TYPE %d", request->APPLICATION_TYPE);
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.SECURITY_TYPE %d", request->SECURITY_TYPE);
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.MVFLength %d", LE16TOH (request->MVFLength));
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.PEV_ID %s", HEXSTRING (string, request->MatchVarField.PEV_ID));
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.PEV_MAC %s", HEXSTRING (string, request->MatchVarField.PEV_MAC));
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.EVSE_ID %s", HEXSTRING (string, request->MatchVarField.EVSE_ID));
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.EVSE_MAC %s", HEXSTRING (string, request->MatchVarField.EVSE_MAC));
slac_debug (session, 0, __func__, "CM_SLAC_MATCH.REQ.RunID %s", HEXSTRING (string, request->MatchVarField.RunID));
}
#endif
slac_debug (session, 0, __func__, "--> CM_SLAC_MATCH.CNF");
memset (message, 0, sizeof (* message));
EthernetHeader (& confirm->ethernet, session->PEV_MAC, channel->host, channel->type);
HomePlugHeader1 (& confirm->homeplug, HOMEPLUG_MMV, (CM_SLAC_MATCH | MMTYPE_CNF));
confirm->APPLICATION_TYPE = session->APPLICATION_TYPE;
confirm->SECURITY_TYPE = session->SECURITY_TYPE;
confirm->MVFLength = HTOLE16 (sizeof (confirm->MatchVarField));
memcpy (confirm->MatchVarField.PEV_ID, session->PEV_ID, sizeof (confirm->MatchVarField.PEV_ID));
memcpy (confirm->MatchVarField.PEV_MAC, session->PEV_MAC, sizeof (confirm->MatchVarField.PEV_MAC));
memcpy (confirm->MatchVarField.EVSE_ID, session->EVSE_ID, sizeof (confirm->MatchVarField.EVSE_ID));
memcpy (confirm->MatchVarField.EVSE_MAC, session->EVSE_MAC, sizeof (confirm->MatchVarField.EVSE_MAC));
memcpy (confirm->MatchVarField.RunID, session->RunID, sizeof (confirm->MatchVarField.RunID));
memcpy (confirm->MatchVarField.NID, session->NID, sizeof (confirm->MatchVarField.NID));
memcpy (confirm->MatchVarField.NMK, session->NMK, sizeof (confirm->MatchVarField.NMK));
if (sendmessage (channel, message, sizeof (* confirm)) <= 0)
{
return (slac_debug (session, 1, __func__, CHANNEL_CANTSEND));
}
return (0);
}
}
return (slac_debug (session, session->exit, __func__, "<-- CM_SLAC_MATCH.REQ ?"));
}
/*
* Get the table of contents (directory) from the cam
*
* Verified: Yes
*/
static int enigma13_get_toc(Camera *camera, int *filecount, char** toc)
{
char* flash_toc=NULL;
int toc_size = 0;
char buf[10];
uint16_t response = 0;
int ret=1;
CHECK(enigma13_wait_for_ready(camera));
CHECK (gp_port_usb_msg_read (camera->port,
0x54, 0x0000, 0x0000,
(char*)&response, 0x02));
LE16TOH (response);
*filecount = response;
/* Calc toc size */
toc_size = (response) * 0x20;
if (toc_size % 0x200 != 0)
toc_size = ((toc_size / 0x200) + 1) * 0x200;
CHECK(enigma13_wait_for_ready(camera));
CHECK (gp_port_usb_msg_write (camera->port, 0x54,
response, 0x0001,
NULL, 0x0000));
/* Wait until cam is ready to send the T.O.C */
usleep(ENIGMA13_WAIT_TOC_DELAY_MS * 1000);
CHECK (gp_port_usb_msg_read (camera->port, 0x21,
0x0000, 0x0000,
buf, 0x01));
if (buf[0]!=0x41) return GP_ERROR;
CHECK (gp_port_usb_msg_read (camera->port, 0x21,
0x0000, 0x0002,
buf, 0x01));
if (buf[0]!=0x01) return GP_ERROR;
flash_toc = (char*)malloc(toc_size);
if (!flash_toc)
return GP_ERROR_NO_MEMORY;
ret=gp_port_read (camera->port, flash_toc, toc_size);
*toc= flash_toc;
gp_log(GP_LOG_DEBUG, "enigma13","Byte transferred :%d ", ret);
return ret;
}
signed ChangeIdent (struct plc * plc)
{
struct simple_pib simple_pib;
memset (&simple_pib, 0, sizeof (simple_pib));
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTREAD, plc->PIB.name);
}
memcpy (simple_pib.MAC, plc->MAC, sizeof (simple_pib.MAC));
memcpy (simple_pib.DAK, plc->DAK, sizeof (simple_pib.DAK));
memcpy (simple_pib.NMK, plc->NMK, sizeof (simple_pib.NMK));
{
uint8_t level = simple_pib.PreferredNID [HPAVKEY_NID_LEN-1] >> 4;
HPAVKeyNID (simple_pib.PreferredNID, simple_pib.NMK, level & 1);
}
simple_pib.CHECKSUM = 0;
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (write (plc->PIB.file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTSAVE, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
simple_pib.CHECKSUM = fdchecksum32 (plc->PIB.file, LE16TOH (simple_pib.PIBLENGTH), 0);
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (write (plc->PIB.file, &simple_pib, sizeof (simple_pib)) != sizeof (simple_pib))
{
error (1, errno, FILE_CANTSAVE, plc->PIB.name);
}
return (0);
}
signed FirmwareMessage (void const * memory)
{
const struct message * message = (const struct message *)(memory);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
static struct qualcomm_hdr header_arpc =
{
0,
0,
{
0x00,
0xB0,
0x52
}
};
struct __packed vs_arpc_indicate
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint16_t RDATALENGTH;
uint8_t RDATAOFFSET;
uint8_t RDATA [1];
}
* indicate = (struct vs_arpc_indicate *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
header_arpc.MMTYPE = HTOLE16 (VS_ARPC | MMTYPE_IND);
if (!memcmp (&indicate->qualcomm, &header_arpc, sizeof (header_arpc)))
{
ARPCPrint (stderr, &indicate->RDATA [indicate->RDATAOFFSET], LE16TOH (indicate->RDATALENGTH) - indicate->RDATAOFFSET);
return (-1);
}
return (0);
}
signed ModuleWrite (struct plc * plc, struct _file_ * file, unsigned index, struct vs_module_spec * vs_module_spec)
{
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_write_request
{
struct ethernet_std ethernet;
struct qualcomm_std 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;
uint32_t MOD_OP_SESSION_ID;
uint8_t MODULE_IDX;
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];
}
* request = (struct vs_module_operation_write_request *)(message);
struct __packed vs_module_operation_write_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std 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;
uint32_t MOD_OP_SESSION_ID;
uint8_t MODULE_IDX;
uint16_t MODULE_ID;
uint16_t MODULE_SUB_ID;
uint16_t MODULE_LENGTH;
uint32_t MODULE_OFFSET;
}
MODULE_SPEC;
}
* confirm = (struct vs_module_operation_write_confirm *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
unsigned timeout = channel->timeout;
uint16_t length = PLC_MODULE_SIZE;
uint32_t extent = vs_module_spec->MODULE_LENGTH;
uint32_t offset = 0;
Request (plc, "Flash %s", file->name);
while (extent)
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, HOMEPLUG_MTYPE);
QualcommHeader (&request->qualcomm, 0, (VS_MODULE_OPERATION | MMTYPE_REQ));
plc->packetsize = sizeof (struct vs_module_operation_write_request);
if (length > extent)
{
length = extent;
}
if (read (file->file, request->MODULE_DATA, length) != length)
{
error (1, errno, FILE_CANTREAD, file->name);
}
request->NUM_OP_DATA = 1;
request->MODULE_SPEC.MOD_OP = HTOLE16 (PLC_MOD_OP_WRITE_MODULE);
request->MODULE_SPEC.MOD_OP_DATA_LEN = HTOLE16 (sizeof (request->MODULE_SPEC) + sizeof (request->MODULE_DATA));
request->MODULE_SPEC.MOD_OP_SESSION_ID = HTOLE32 (plc->cookie);
request->MODULE_SPEC.MODULE_IDX = index;
request->MODULE_SPEC.MODULE_ID = HTOLE16 (vs_module_spec->MODULE_ID);
request->MODULE_SPEC.MODULE_SUB_ID = HTOLE16 (vs_module_spec->MODULE_SUB_ID);
request->MODULE_SPEC.MODULE_LENGTH = HTOLE16 (length);
request->MODULE_SPEC.MODULE_OFFSET = HTOLE32 (offset);
#if 0
fprintf (stderr, "RESERVED 0x%08X\n", LE32TOH (request->RESERVED));
fprintf (stderr, "NUM_OP_DATA %d\n", request->NUM_OP_DATA);
fprintf (stderr, "MOD_OP 0x%02X\n", LE16TOH (request->MODULE_SPEC.MOD_OP));
fprintf (stderr, "MOD_OP_DATA_LEN %d\n", LE16TOH (request->MODULE_SPEC.MOD_OP_DATA_LEN));
fprintf (stderr, "RESERVED 0x%08X\n", LE32TOH (request->MODULE_SPEC.MOD_OP_RSVD));
fprintf (stderr, "MODULE_ID 0x%04X\n", LE16TOH (request->MODULE_SPEC.MODULE_ID));
fprintf (stderr, "MODULE_SUB_ID 0x%04X\n", LE16TOH (request->MODULE_SPEC.MODULE_SUB_ID));
fprintf (stderr, "MODULE_LENGTH %d\n", LE16TOH (request->MODULE_SPEC.MODULE_LENGTH));
fprintf (stderr, "MODULE_OFFSET 0x%08X\n", LE32TOH (request->MODULE_SPEC.MODULE_OFFSET));
#endif
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
channel->timeout = PLC_MODULE_WRITE_TIMEOUT;
if (ReadMME (plc, 0, (VS_MODULE_OPERATION | MMTYPE_CNF)) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTREAD);
channel->timeout = timeout;
return (-1);
}
channel->timeout = timeout;
#if 0
fprintf (stderr, "MSTATUS 0x%04X\n", LE16TOH (confirm->MSTATUS));
fprintf (stderr, "ERROR_REC_CODE %d\n", LE16TOH (confirm->ERR_REC_CODE));
fprintf (stderr, "RESERVED 0x%08X\n", LE32TOH (confirm->RESERVED));
fprintf (stderr, "NUM_OP_DATA %d\n", confirm->NUM_OP_DATA);
fprintf (stderr, "MOD_OP 0x%02X\n", LE16TOH (request->MODULE_SPEC.MOD_OP));
fprintf (stderr, "MOD_OP_DATA_LEN %d\n", LE16TOH (confirm->MODULE_SPEC.MOD_OP_DATA_LEN));
fprintf (stderr, "RESERVED 0x%08X\n", LE32TOH (confirm->MODULE_SPEC.MOD_OP_RSVD));
fprintf (stderr, "MODULE_ID 0x%04X\n", LE16TOH (confirm->MODULE_SPEC.MODULE_ID));
fprintf (stderr, "MODULE_SUB_ID 0x%04X\n", LE16TOH (confirm->MODULE_SPEC.MODULE_SUB_ID));
fprintf (stderr, "MODULE_LENGTH %d\n", LE16TOH (confirm->MODULE_SPEC.MODULE_LENGTH));
fprintf (stderr, "MODULE_OFFSET 0x%08X\n", LE32TOH (request->MODULE_SPEC.MODULE_OFFSET));
#endif
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
if (LE16TOH (confirm->MODULE_SPEC.MODULE_LENGTH) != length)
{
error ((plc->flags & PLC_BAILOUT), 0, PLC_ERR_LENGTH);
return (-1);
}
if (LE32TOH (confirm->MODULE_SPEC.MODULE_OFFSET) != offset)
{
error ((plc->flags & PLC_BAILOUT), 0, PLC_ERR_OFFSET);
return (-1);
}
extent -= length;
offset += length;
}
return (0);
}
signed EmulateHost (struct plc * plc)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
static char const * actions [] =
{
"start device",
"store firmware",
"store parameters",
"update host",
"config memory",
"restore defaults",
"unknown"
};
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_host_action_ind
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MACTION;
uint8_t MAJOR_VERSION;
uint8_t MINOR_VERSION;
}
* indicate = (struct vs_host_action_ind *) (message);
#if 0
struct __packed vs_host_action_rsp
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
}
* response = (struct vs_host_action_rsp *) (message);
#endif
#ifndef __GNUC__
#pragma pack (pop)
#endif
struct nvm_header1 nvm_header;
struct pib_header pib_header;
uint32_t offset;
char const * PIB = plc->PIB.name;
char const * NVM = plc->NVM.name;
signed timer = channel->timeout;
signed status = 0;
Request (plc, "Waiting for Host Action");
while (1)
{
channel->timeout = plc->timer;
status = ReadMME (plc, 0, (VS_HOST_ACTION | MMTYPE_IND));
channel->timeout = timer;
if (status < 0)
{
break;
}
if (status > 0)
{
printf ("\n");
if (indicate->MACTION < (sizeof (actions) / sizeof (char const *)))
{
Confirm (plc, "Host Action Request is (%d) %s.", indicate->MACTION, actions [indicate->MACTION]);
}
else
{
error (0, ENOTSUP, "Host Action 0x%0X", indicate->MACTION);
continue;
}
memcpy (channel->peer, indicate->ethernet.OSA, sizeof (channel->peer));
channel->timeout = timer;
if (indicate->MACTION == 0x00)
{
unsigned module = 0;
char firmware [PLC_VERSION_STRING];
if (HostActionResponse (plc))
{
return (-1);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &pib_header, sizeof (pib_header)) != sizeof (pib_header))
{
error (1, errno, FILE_CANTREAD, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
if (WriteMEM (plc, &plc->PIB, 0, offset, LE16TOH (pib_header.PIBLENGTH)))
{
return (-1);
}
if (lseek (plc->NVM.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->NVM.name);
}
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
while (nvm_header.NEXTHEADER)
{
lseek (plc->NVM.file, LE32TOH (nvm_header.NEXTHEADER), SEEK_SET);
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
module++;
}
if (WriteFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (StartFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (WaitForStart (plc, firmware, sizeof (firmware)))
{
return (-1);
}
if (_anyset (plc->flags, PLC_FLASH_DEVICE))
{
if (WriteNVM (plc))
{
return (-1);
}
if (WritePIB (plc))
{
return (-1);
}
if (FlashNVM (plc))
{
return (-1);
}
}
continue;
}
if (indicate->MACTION == 0x01)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if (ReadFirmware1 (plc))
{
return (-1);
}
if ((plc->NVM.file = open (plc->NVM.name = plc->nvm.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x02)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->PIB.file);
if (ReadParameters1 (plc))
{
return (-1);
}
if ((plc->PIB.file = open (plc->PIB.name = plc->pib.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x03)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if (ReadFirmware1 (plc))
{
return (-1);
}
if ((plc->NVM.file = open (plc->NVM.name = plc->nvm.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
close (plc->PIB.file);
if (ReadParameters1 (plc))
{
return (-1);
}
if ((plc->PIB.file = open (plc->PIB.name = plc->pib.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x04)
{
#if 0
/*
* Due to an omission in the INT6300 BootLoader, responding to this VS_HOST_ACTION
* indication will suppress subsequent VS_HOST_ACTION messages and the device will
* not request firmware and parameters; this may be corrected on the INT6400;
*/
if (HostActionResponse (plc))
{
return (-1);
}
#endif
if (WriteCFG (plc))
{
return (-1);
}
/*
* At this point, one could download firmware and parameters without waiting for
* further requests from the device; however, we elect to wait for them since it
* is 'good form'; a device should send code 0x00 within 10 seconds of this one;
*/
continue;
}
if (indicate->MACTION == 0x05)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if ((plc->NVM.file = open (plc->NVM.name = NVM, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
close (plc->PIB.file);
if ((plc->PIB.file = open (plc->PIB.name = PIB, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
error (0, ENOSYS, "Host Action 0x%0X", indicate->MACTION);
}
}
return (0);
}
signed MDUTrafficStats (struct plc * plc, uint8_t command, uint8_t session, uint8_t slave)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_mdu_station_stats_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t COMMAND;
uint8_t SESSION;
uint32_t SLAVE_BITMAP [8];
}
* request = (struct vs_mdu_station_stats_request *) (message);
struct __packed vs_mdu_traffic_master_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t COMMAND;
uint8_t SESSION;
uint16_t RESERVED;
uint8_t NUM_SLAVES;
uint8_t NUM_SLAVES_LEFT;
uint16_t STATS_LEN;
struct station_stats STATS [1];
}
* master_confirm = (struct vs_mdu_traffic_master_confirm *) (message);
struct __packed vs_mdu_traffic_slave_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t COMMAND;
uint8_t SESSION;
uint16_t STATS_LEN;
struct station_stats STATS [1];
}
* slave_confirm = (struct vs_mdu_traffic_slave_confirm *) (message);
#if 1
struct __packed vs_eth_hardware_stats_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t COMMAND;
uint8_t SESSION;
uint8_t CHIPTYPE;
uint8_t STATUS;
uint16_t STATS_LEN;
struct ethernet_stats STATS [1];
}
* ether_confirm = (struct vs_eth_hardware_stats_confirm *) (message);
#endif
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Request MDU Traffic Statistics (1)");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_MDU_TRAFFIC_STATS | MMTYPE_REQ));
request->COMMAND = command;
request->SESSION = session;
set32bitmap (request->SLAVE_BITMAP, slave);
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_MDU_TRAFFIC_STATS | MMTYPE_CNF)) > 0)
{
if ((request->COMMAND > 0x00) && (request->COMMAND < 0x0020))
{
struct station_stats * stats;
unsigned count;
if (_anyset (request->COMMAND, MASTER_TX_RX | SLAVE_TX_RX))
{
stats = master_confirm->STATS;
count = LE16TOH (master_confirm->STATS_LEN);
}
else
{
stats = slave_confirm->STATS;
count = LE16TOH (slave_confirm->STATS_LEN);
}
while (count >= sizeof (struct station_stats))
{
StationStats (plc, stats++);
count -= sizeof (struct station_stats);
}
continue;
}
if ((request->COMMAND >= 0x20) && (request->COMMAND < 0x24))
{
EthernetStats (plc, ether_confirm->STATS);
continue;
}
if ((request->COMMAND >= 0x24) && (request->COMMAND < 0x28))
{
EthernetStats (plc, ether_confirm->STATS);
continue;
}
if ((request->COMMAND >= 0x28) && (request->COMMAND < 0x32))
{
EthernetStats (plc, ether_confirm->STATS);
continue;
}
}
return (0);
}
signed evse_cm_mnbc_sound (struct session * session, struct channel * channel, struct message * message)
{
struct timeval ts;
struct timeval tc;
signed timer = 100 * session->TIME_OUT;
unsigned AAG [SLAC_GROUPS];
unsigned sounds = 0;
ssize_t length;
session->sounds = 0;
memset (AAG, 0, sizeof (AAG));
memset (session->AAG, 0, sizeof (session->AAG));
if (gettimeofday (& ts, NULL) == - 1)
{
slac_debug (session, 1, __func__, CANT_START_TIMER);
}
while ((length = readpacket (channel, message, sizeof (* message))) >= 0)
{
struct homeplug * homeplug = (struct homeplug *) (message);
if (! length)
{
}
else if (ntohs (homeplug->ethernet.MTYPE) != ETH_P_HPAV)
{
slac_debug (session, session->exit, __func__, "bad MTYPE");
}
else if (homeplug->homeplug.MMV != HOMEPLUG_MMV)
{
slac_debug (session, session->exit, __func__, "bad MMV");
}
else if (LE16TOH (homeplug->homeplug.MMTYPE) == (CM_MNBC_SOUND | MMTYPE_IND))
{
struct cm_mnbc_sound_indicate * indicate = (struct cm_mnbc_sound_indicate *) (message);
if (! memcmp (session->RunID, indicate->MSVarField.RunID, sizeof (session->RunID)))
{
slac_debug (session, 0, __func__, "<-- CM_MNBC_SOUND.IND (%d)", sounds);
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.APPLICATION_TYPE %d", indicate->APPLICATION_TYPE);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.SECURITY_TYPE %d", indicate->SECURITY_TYPE);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.SenderID %s", HEXSTRING (string, indicate->MSVarField.SenderID));
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.Count %d", indicate->MSVarField.CNT);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.RunID %s", HEXSTRING (string, indicate->MSVarField.RunID));
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.RND %s", HEXSTRING (string, indicate->MSVarField.RND));
}
#endif
if (memcmp (session->PEV_MAC, indicate->ethernet.OSA, sizeof (session->PEV_MAC)))
{
slac_debug (session, session->exit, __func__, "Unexpected OSA");
}
sounds++;
}
}
else if (LE16TOH (homeplug->homeplug.MMTYPE) == (CM_ATTEN_PROFILE | MMTYPE_IND))
{
struct cm_atten_profile_indicate * indicate = (struct cm_atten_profile_indicate *) (message);
if (! memcmp (session->PEV_MAC, indicate->PEV_MAC, sizeof (session->PEV_MAC)))
{
slac_debug (session, 0, __func__, "<-- CM_ATTEN_PROFILE.IND (%d)", session->sounds);
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.PEV_MAC %s", HEXSTRING (string, indicate->PEV_MAC));
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.NumGroups %d", indicate->NumGroups);
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.AAG %s", hexstring (string, sizeof (string), indicate->AAG, indicate->NumGroups));
}
#endif
for (session->NumGroups = 0; session->NumGroups < indicate->NumGroups; session->NumGroups++)
{
AAG [session->NumGroups] += indicate->AAG [session->NumGroups];
}
session->NumGroups = indicate->NumGroups;
session->sounds++;
}
}
if (gettimeofday (& tc, NULL) == - 1)
{
slac_debug (session, 1, __func__, CANT_RESET_TIMER);
}
if ((MILLISECONDS (ts, tc) < timer) && (session->sounds < session->NUM_SOUNDS))
{
continue;
}
if (session->sounds > 0)
{
for (session->NumGroups = 0; session->NumGroups < SLAC_GROUPS; ++ session->NumGroups)
{
session->AAG [session->NumGroups] = AAG [session->NumGroups] / session->sounds;
}
}
return (0);
}
return (slac_debug (session, session->exit, __func__, "Sound timeout"));
}
signed ReadFirmware1 (struct plc * plc)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_rd_mod_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MODULEID;
uint8_t MACCESS;
uint16_t MLENGTH;
uint32_t MOFFSET;
uint8_t MSECRET [16];
}
* request = (struct vs_rd_mod_request *) (message);
struct __packed vs_rd_mod_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t RES [3];
uint8_t MODULEID;
uint8_t RESERVED;
uint16_t MLENGTH;
uint32_t MOFFSET;
uint32_t CHKSUM;
uint8_t BUFFER [PLC_RECORD_SIZE];
}
* confirm = (struct vs_rd_mod_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
uint32_t header = 0;
uint32_t extent = 0;
uint32_t offset = 0;
uint16_t length = PLC_RECORD_SIZE;
Request (plc, "Read Firmware from Device");
if (lseek (plc->nvm.file, 0, SEEK_SET))
{
error (PLC_EXIT (plc), errno, FILE_CANTHOME, plc->nvm.name);
return (1);
}
do
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_RD_MOD | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->MODULEID = VS_MODULE_MAC;
request->MLENGTH = HTOLE16 (length);
request->MOFFSET = HTOLE32 (offset);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_RD_MOD | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
if (LE16TOH (confirm->MLENGTH) != length)
{
error (PLC_EXIT (plc), 0, PLC_ERR_LENGTH);
return (-1);
}
if (LE32TOH (confirm->MOFFSET) != offset)
{
error (PLC_EXIT (plc), 0, PLC_ERR_OFFSET);
return (-1);
}
length = LE16TOH (confirm->MLENGTH);
offset = LE32TOH (confirm->MOFFSET);
if (checksum32 (confirm->BUFFER, length, confirm->CHKSUM))
{
error (PLC_EXIT (plc), ECANCELED, "Bad Packet Checksum");
return (-1);
}
if (offset == extent)
{
struct nvm_header1 * nvm_header = (struct nvm_header1 *)(confirm->BUFFER);
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
error (PLC_EXIT (plc), ECANCELED, "Bad Header Checksum");
return (-1);
}
if (LE32TOH (nvm_header->HEADERVERSION) != 0x60000000)
{
error (PLC_EXIT (plc), ECANCELED, "Bad Header Version");
return (-1);
}
extent += sizeof (* nvm_header);
extent += LE32TOH (nvm_header->IMAGELENGTH);
header = LE32TOH (nvm_header->NEXTHEADER);
}
if ((offset + length) > extent)
{
length = extent - offset;
}
if (lseek (plc->nvm.file, offset, SEEK_SET) != (off_t)(offset))
{
error (PLC_EXIT (plc), errno, FILE_CANTSEEK, plc->nvm.name);
return (-1);
}
if (write (plc->nvm.file, confirm->BUFFER, length) != (signed)(length))
{
error (PLC_EXIT (plc), errno, FILE_CANTSEEK, plc->nvm.name);
return (-1);
}
offset += length;
length = 1024;
}
while ((header) || (offset < extent));
Confirm (plc, "Read %s", plc->nvm.name);
return (0);
}
static void function2 (char const * filename, flag_t flags)
{
struct nvm_header2 nvm_header;
char savename [FILENAME_MAX];
byte buffer [BUFSIZ];
signed image = 0;
signed offset = 0;
signed ifd;
signed ofd;
char * sp;
char * cp;
memset (&nvm_header, 0, sizeof (nvm_header));
for (sp = cp = strcpy (savename, filename); *cp; cp++)
{
if (*cp == FILE_C_EXTENDER)
{
sp = cp;
}
}
if (sp == savename)
{
sp = cp;
}
if ((ifd = open (filename, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, FILE_CANTOPEN, filename);
}
do
{
signed extent;
signed length;
if (lseek (ifd, 0, SEEK_CUR) != offset)
{
error (1, errno, NVM_HDR_LINK, filename, image);
}
if (read (ifd, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTREAD, filename, image);
}
if (LE16TOH (nvm_header.MinorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, filename, image);
}
if (LE16TOH (nvm_header.MajorVersion) != 1)
{
error (1, 0, NVM_HDR_VERSION, filename, image);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
error (1, 0, NVM_HDR_CHECKSUM, filename, image);
}
#if defined (WIN32)
sprintf (sp, "-%02d.nvm", image);
#else
snprintf (sp, savename + sizeof (savename) - sp, "-%02d.nvm", image);
#endif
if ((ofd = open (savename, O_BINARY|O_WRONLY|O_CREAT|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, FILE_CANTOPEN, savename);
}
if (_anyset (flags, NVM_VERBOSE))
{
error (0, 0, "%s --> %s", filename, savename);
}
offset = LE32TOH (nvm_header.NextHeader);
nvm_header.NextHeader = ~0;
nvm_header.PrevHeader = ~0;
nvm_header.HeaderChecksum = 0;
nvm_header.HeaderChecksum = checksum32 (&nvm_header, sizeof (nvm_header), 0);
if (write (ofd, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTSAVE, savename, image);
}
extent = LE32TOH (nvm_header.ImageLength);
length = sizeof (buffer);
while (extent)
{
if (length > extent)
{
length = extent;
}
if (read (ifd, buffer, length) < length)
{
error (1, errno, NVM_IMG_CANTREAD, filename, image);
}
if (write (ofd, buffer, length) < length)
{
error (1, errno, NVM_IMG_CANTSAVE, savename, image);
}
extent -= length;
}
close (ofd);
image++;
}
while (~offset);
close (ifd);
return;
}
static signed PrintCheckpointReport (struct plc * plc, char const * version)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_cp_rpt_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint16_t SESSIONID;
uint8_t CLR;
}
* request = (struct vs_cp_rpt_request *) (message);
struct __packed vs_cp_rpt_ind
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MAJORVERSION;
uint8_t MINORVERSION;
uint8_t RESERVED [14];
uint16_t SESSIONID;
uint32_t TOTALBUFFERSIZE;
uint32_t BLOCKOFFSET;
uint32_t BYTEINDEXOFNEXTPOSITION;
uint8_t NUMPARTS;
uint8_t CURPART;
uint16_t RDATALENGTH;
uint8_t RDATAOFFSET;
uint8_t RDATA [1];
}
* indicate = (struct vs_cp_rpt_ind *) (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_CP_RPT | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->SESSIONID = HTOLE16 (plc->cookie);
request->CLR = plc->readaction;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
printf ("<CheckpointReport>");
do
{
if (ReadMME (plc, 0, (VS_CP_RPT | MMTYPE_IND)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (_anyset (indicate->MSTATUS, MSTATUS_STATUS))
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
printf ("<Packet>");
printf ("<Version>%s</Version>", version);
printf ("<Status>0</Status>");
printf ("<MajorVersionBit>%d</MajorVersionBit>", indicate->MSTATUS & MSTATUS_MAJORVERSION? 1:0);
printf ("<BufferIsLocked>%d</BufferIsLocked>", indicate->MSTATUS & MSTATUS_BUFFERISLOCKED? 1:0);
printf ("<AutoLockOnResetIsOn>%d</AutoLockOnResetIsOn>", indicate->MSTATUS & MSTATUS_AUTOLOCKONRESET? 1:0);
printf ("<UnsolicitedUpdatesIsOn>%d</UnsolicitedUpdatesIsOn>", indicate->MSTATUS & MSTATUS_UNSOLICITEDUPDATES? 1:0);
printf ("<Unsolicited>%d</Unsolicited>", indicate->MSTATUS & MSTATUS_UNSOLICITED? 1:0);
printf ("<MajorVersion>%d</MajorVersion>", indicate->MAJORVERSION);
printf ("<MinorVersion>%d</MinorVersion>", indicate->MINORVERSION);
printf ("<Reserved1>0</Reserved1>");
printf ("<Reserved2>0</Reserved2>");
printf ("<Reserved3>0</Reserved3>");
printf ("<Reserved4>0</Reserved4>");
printf ("<SessionId>1</SessionId>");
printf ("<TotalBufferSize>%d</TotalBufferSize>", LE32TOH (indicate->TOTALBUFFERSIZE));
printf ("<BlockOffset>%d</BlockOffset>", LE32TOH (indicate->BLOCKOFFSET));
printf ("<ByteIndexOfNextPos>%d</ByteIndexOfNextPos>", LE32TOH (indicate->BYTEINDEXOFNEXTPOSITION));
printf ("<NumParts>%d</NumParts>", indicate->NUMPARTS);
printf ("<CurPart>%d</CurPart>", indicate->CURPART);
printf ("<RDataLength>%d</RDataLength>", LE16TOH (indicate->RDATALENGTH));
printf ("<RDataOffset>%d</RDataOffset>", indicate->RDATAOFFSET);
printf ("<RData>");
b64dump (indicate->RDATA + indicate->RDATAOFFSET, LE16TOH (indicate->RDATALENGTH), 0, stdout);
printf ("</RData>");
printf ("</Packet>");
}
while (indicate->CURPART < indicate->NUMPARTS);
printf ("</CheckpointReport>");
return (0);
}
static signed PrintWatchdogReport (struct plc * plc, char const * version)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_wd_rpt_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint16_t SESSIONID;
uint8_t CLR;
}
* request = (struct vs_wd_rpt_request *) (message);
struct __packed vs_wd_rpt_ind
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint16_t SESSIONID;
uint8_t NUMPARTS;
uint8_t CURPART;
uint16_t RDATALENGTH;
uint8_t RDATAOFFSET;
uint8_t RDATA [1];
}
* indicate = (struct vs_wd_rpt_ind *) (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_WD_RPT | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->SESSIONID = HTOLE16 (plc->cookie);
request->CLR = plc->readaction;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
printf ("<WatchdogReport>");
do
{
if (ReadMME (plc, 0, (VS_WD_RPT | MMTYPE_IND)) < 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (indicate->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
printf ("<Packet>");
printf ("<Version>%s</Version>", version);
printf ("<OUI>%s</OUI>", "00B052");
printf ("<Status>0</Status>");
printf ("<SessionId>0</SessionId>");
printf ("<NumParts>%d</NumParts>", indicate->NUMPARTS);
printf ("<CurPart>%d</CurPart>", indicate->CURPART);
printf ("<DataLength>%d</DataLength>", LE16TOH (indicate->RDATALENGTH));
printf ("<DataOffset>%d</DataOffset>", indicate->RDATAOFFSET);
printf ("<Data>");
b64dump (indicate->RDATA + indicate->RDATAOFFSET, LE16TOH (indicate->RDATALENGTH) - indicate->RDATAOFFSET, 0, stdout);
printf ("</Data>");
printf ("</Packet>");
}
while (indicate->CURPART < indicate->NUMPARTS);
printf ("</WatchdogReport>");
return (0);
}
signed WriteMOD (struct plc * plc, uint8_t module, void const * memory, size_t extent)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_wr_mod_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MODULEID;
uint8_t MACCESS;
uint16_t MLENGTH;
uint32_t MOFFSET;
uint32_t MCHKSUM;
uint8_t MBUFFER [PLC_RECORD_SIZE];
}
* request = (struct vs_wr_mod_request *) (message);
struct __packed vs_wr_mod_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MODULEID;
uint8_t MACCESS;
uint16_t MLENGTH;
uint32_t MOFFSET;
}
* confirm = (struct vs_wr_mod_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
uint32_t length = PLC_RECORD_SIZE;
uint32_t offset = 0;
while (extent)
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_WR_MOD | MMTYPE_REQ));
if (length > extent)
{
length = (signed)(extent);
}
memcpy (request->MBUFFER, (byte *)(memory) + offset, length);
request->MODULEID = module;
request->MACCESS = 0;
request->MLENGTH = HTOLE16 (length);
request->MOFFSET = HTOLE32 (offset);
request->MCHKSUM = checksum32 (request->MBUFFER, length, 0);
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_WR_MOD | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
if (LE16TOH (confirm->MLENGTH) != length)
{
error (PLC_EXIT (plc), 0, PLC_ERR_LENGTH);
return (-1);
}
if (LE32TOH (confirm->MOFFSET) != offset)
{
error (PLC_EXIT (plc), 0, PLC_ERR_OFFSET);
return (-1);
}
offset += length;
extent -= length;
}
return (0);
}
static signed PrintRawWatchdogReport (struct plc * plc)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_wd_rpt_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint16_t SESSIONID;
uint8_t CLR;
}
* request = (struct vs_wd_rpt_request *) (message);
struct __packed vs_wd_rpt_indicate
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint16_t SESSIONID;
uint8_t NUMPARTS;
uint8_t CURPART;
uint16_t RDATALENGTH;
uint8_t RDATAOFFSET;
uint8_t RDATA [1];
}
* indicate = (struct vs_wd_rpt_indicate *) (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_WD_RPT | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->SESSIONID = HTOLE16 (plc->cookie);
request->CLR = plc->readaction;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
do
{
printf ("%d %d\n", LE16TOH (indicate->RDATALENGTH), indicate->RDATAOFFSET);
if (ReadMME (plc, 0, (VS_WD_RPT | MMTYPE_IND)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
printf ("%d %d\n", LE16TOH (indicate->RDATALENGTH), indicate->RDATAOFFSET);
if (indicate->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
printf ("%d %d\n", LE16TOH (indicate->RDATALENGTH), indicate->RDATAOFFSET);
write (STDOUT_FILENO, indicate->RDATA + indicate->RDATAOFFSET, LE16TOH (indicate->RDATALENGTH) - indicate->RDATAOFFSET);
}
while (indicate->CURPART < indicate->NUMPARTS);
return (0);
}
static signed nvmchain2 (void const * memory, size_t extent, char const * filename, flag_t flags)
{
struct nvm_header2 * nvm_header;
unsigned module = 0;
uint32_t origin = ~0;
uint32_t offset = 0;
uint32_t length = 0;
do
{
nvm_header = (struct nvm_header2 *)((char *)(memory) + offset);
if (LE16TOH (nvm_header->MajorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE16TOH (nvm_header->MinorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE32TOH (nvm_header->PrevHeader) != origin)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
return (-1);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, 0, NVM_HDR_CHECKSUM, filename, module);
}
return (-1);
}
origin = offset;
offset += sizeof (* nvm_header);
extent -= sizeof (* nvm_header);
length = LE32TOH (nvm_header->ImageLength);
if (_anyset (flags, NVM_VERBOSE))
{
printf ("------- %s (%d) -------\n", filename, module);
nvmpeek2 (nvm_header);
}
if (LE32TOH (nvm_header->ImageType) == NVM_IMAGE_MANIFEST)
{
if (_anyset (flags, NVM_MANIFEST))
{
printf ("------- %s (%d) -------\n", filename, module);
manifest ((char *)(memory) + offset, length);
return (0);
}
}
if (checksum32 ((char *)(memory) + offset, length, nvm_header->ImageChecksum))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_IMG_CHECKSUM, filename, module);
}
return (-1);
}
offset += length;
extent -= length;
module++;
}
while (~nvm_header->NextHeader);
if (extent)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
}
return (0);
}