signed Antiphon (struct plc * plc, byte source [], byte target [])
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_fr_lbk_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t DURATION;
uint8_t RESERVED;
uint16_t LENGTH;
uint8_t PACKET [1038];
}
* request = (struct vs_fr_lbk_request *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
if (_allclr (plc->flags, PLC_SILENCE))
{
char sourcename [ETHER_ADDR_LEN * 3];
char targetname [ETHER_ADDR_LEN * 3];
hexdecode (source, ETHER_ADDR_LEN, sourcename, sizeof (sourcename));
hexdecode (target, ETHER_ADDR_LEN, targetname, sizeof (targetname));
fprintf (stderr, "%s %s %s\n", channel->ifname, sourcename, targetname);
}
memset (message, 0, sizeof (* message));
EthernetHeader (&message->ethernet, source, channel->host, HOMEPLUG_MTYPE);
QualcommHeader (&message->qualcomm, 0, (VS_FR_LBK | MMTYPE_REQ));
request->DURATION = plc->timer;
request->LENGTH = HTOLE16 (sizeof (request->PACKET));
memset (request->PACKET, 0xA5, sizeof (request->PACKET));
EthernetHeader (request->PACKET, target, source, ETHERTYPE_IP);
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error (1, errno, CHANNEL_CANTSEND);
}
if (ReadMME (plc, 0, (VS_FR_LBK | MMTYPE_CNF)) <= 0)
{
error (1, errno, CHANNEL_CANTREAD);
}
sleep (plc->timer);
return (0);
}
static signed DefaultVLANIDs (struct plc * plc, struct item list [], unsigned items)
{
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;
uint16_t VLANID;
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;
}
* 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_SET;
request->MVERSION = PLCFWD_VER;
request->VLANID = HTOLE16 (list [0].VLANID [0]);
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;
}
}
return (0);
}
signed RemoteHosts (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_sw_ver_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
}
* request = (struct vs_sw_ver_request *) (message);
struct __packed vs_sw_ver_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint32_t NUMDEVICES;
struct __packed
{
uint8_t MACADDRESS [ETHER_ADDR_LEN];
uint8_t ENUMID;
}
DEVICE [1];
}
* confirm = (struct vs_sw_ver_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Request Enumeration ID Table");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_EM_ID_TABLE | MMTYPE_REQ));
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_EM_ID_TABLE | MMTYPE_CNF)) > 0)
{
unsigned count = LE32TOH (confirm->NUMDEVICES);
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
while (count--)
{
hexout (confirm->DEVICE [count].MACADDRESS, ETHER_ADDR_LEN, ':', count? ' ': '\n', stdout);
}
}
return (0);
}
static signed mod_conn (struct plc * plc, uint8_t TYPE, uint16_t CID)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_mod_conn_req
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint32_t REQ_ID;
uint32_t RSVD;
uint16_t CID;
uint8_t MOD_CTRL;
}
* request = (struct vs_mod_conn_req *)(message);
struct __packed vs_mod_conn_cnf
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint32_t REQ_ID;
uint8_t MSTATUS;
uint16_t ERR_REC_CODE;
uint32_t RSVD;
uint16_t CID;
}
* confirm = (struct vs_mod_conn_cnf *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "COQOS modify connection");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, HOMEPLUG_MTYPE);
QualcommHeader (&request->qualcomm, 0, (VS_MOD_CONN | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->MOD_CTRL = TYPE;
request->CID = CID;
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_MOD_CONN | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
Confirm (plc, "%s connection %04X", (TYPE == ACTION_SPND)? "Suspended": "Resumed", CID);
}
return (0);
}
signed rel_conn (struct plc * plc, uint16_t CID)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_rel_conn_req
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t REQ_ID;
uint32_t RSVD;
uint16_t CID;
}
* request = (struct vs_rel_conn_req *)(message);
struct __packed vs_rel_conn_cnf
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t REQ_ID;
uint8_t MSTATUS;
uint16_t ERR_REC_CODE;
uint32_t RSVD;
}
* confirm = (struct vs_rel_conn_cnf *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Release COQOS connection");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_CONN_REL | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->CID = CID;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_CONN_REL | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
Confirm (plc, "Released %04X", CID);
}
return (0);
}
signed Flash (struct int6k * int6k)
{
struct channel * channel = (struct channel *)(int6k->channel);
struct message * message = (struct message *)(int6k->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_mod_nvm_request
{
struct header_eth ethernet;
struct header_int intellon;
uint8_t MODULEID;
}
* request = (struct vs_mod_nvm_request *) (message);
struct __packed vs_mod_nvm_confirm
{
struct header_eth ethernet;
struct header_int intellon;
uint8_t MSTATUS;
uint8_t MODULEID;
}
* confirm = (struct vs_mod_nvm_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (int6k, "Flash NVRAM");
memset (message, 0, sizeof (struct message));
EthernetHeader (&message->ethernet, channel->peer, channel->host);
IntellonHeader (&message->intellon, (VS_MOD_NVM | MMTYPE_REQ));
int6k->packetsize = ETHER_MIN_LEN;
request->MODULEID = int6k->modulecode;
if (SendMME (int6k) <= 0)
{
error ((int6k->flags & INT6K_BAILOUT), ECANCELED, INT6K_CANTSEND);
return (-1);
}
if (ReadMME (int6k, (VS_MOD_NVM | MMTYPE_CNF)) <= 0)
{
error ((int6k->flags & INT6K_BAILOUT), ECANCELED, INT6K_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (int6k, INT6K_WONTDOIT);
return (-1);
}
Confirm (int6k, "Flashing ...");
return (0);
}
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 ?"));
}
signed Classification (struct plc * plc, struct MMERule * rule)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_classification_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
struct MMERule rule;
}
* request = (struct vs_classification_request *)(message);
struct __packed vs_classification_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t MSTATUS;
}
* confirm = (struct vs_classification_confirm *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Set Classification Rules");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_CLASSIFICATION | MMTYPE_REQ));
plc->packetsize = sizeof (struct vs_classification_request);
memcpy (&request->rule, rule, sizeof (request->rule));
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_CLASSIFICATION | MMTYPE_CNF)) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
Confirm (plc, "Setting ...");
return (0);
}
signed FlashNVM (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_mod_nvm_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t MODULEID;
}
* request = (struct vs_mod_nvm_request *) (message);
struct __packed vs_mod_nvm_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t MSTATUS;
uint8_t MODULEID;
}
* confirm = (struct vs_mod_nvm_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Flash device");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_MOD_NVM | MMTYPE_REQ));
request->MODULEID = plc->module;
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_MOD_NVM | MMTYPE_CNF)) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
return (0);
}
signed HostActionIndicate (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_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);
struct __packed vs_host_action_rsp
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
}
* response = (struct vs_host_action_rsp *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Start Host Action");
memset (message, 0, sizeof (* message));
EthernetHeader (&indicate->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&indicate->qualcomm, 0, (VS_HOST_ACTION | MMTYPE_IND));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
indicate->MACTION = plc->action;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_HOST_ACTION | MMTYPE_RSP)) > 0)
{
if (response->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
Confirm (plc, "Start.");
}
return (0);
}
signed VersionInfo (struct int6k * int6k)
{
extern const char * chipset [CHIPSETS+1];
struct channel * channel = (struct channel *)(int6k->channel);
struct message * message = (struct message *)(int6k->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_confirm
{
struct header_eth ethernet;
struct header_int intellon;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [INT6K_VERSTRING];
uint8_t UPGRADEABLE;
uint32_t MCOOKIE;
}
* confirm = (struct vs_sw_ver_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (int6k, "Request Version Information");
memset (message, 0, sizeof (struct message));
EthernetHeader (&message->ethernet, channel->peer, channel->host);
IntellonHeader (&message->intellon, (VS_SW_VER | MMTYPE_REQ));
int6k->packetsize = ETHER_MIN_LEN;
if (SendMME (int6k) <= 0)
{
error ((int6k->flags & INT6K_BAILOUT), ECANCELED, INT6K_CANTSEND);
return (-1);
}
while (ReadMME (int6k, (VS_SW_VER | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (int6k, INT6K_WONTDOIT);
continue;
}
if (confirm->MDEVICEID > CHIPSETS)
{
confirm->MDEVICEID = 0x00;
}
Display (int6k, "%s %s", chipset [confirm->MDEVICEID], confirm->MVERSION);
}
return (0);
}
signed VersionInfo1 (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_sw_ver_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
}
* request = (struct vs_sw_ver_request *) (message);
struct __packed vs_sw_ver_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* confirm = (struct vs_sw_ver_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Request Version Information");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_SW_VER | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_SW_VER | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
chipset (confirm);
Display (plc, "%s %s", chipsetname (confirm->MDEVICEID), confirm->MVERSION);
}
return (0);
}
signed evse_cm_atten_char (struct session * session, struct channel * channel, struct message * message)
{
struct cm_atten_char_indicate * indicate = (struct cm_atten_char_indicate *) (message);
struct cm_atten_char_response * response = (struct cm_atten_char_response *) (message);
slac_debug (session, 0, __func__, "--> CM_ATTEN_CHAR.IND");
memset (message, 0, sizeof (* message));
EthernetHeader (& indicate->ethernet, session->PEV_MAC, channel->host, channel->type);
HomePlugHeader1 (& indicate->homeplug, HOMEPLUG_MMV, (CM_ATTEN_CHAR | MMTYPE_IND));
indicate->APPLICATION_TYPE = session->APPLICATION_TYPE;
indicate->SECURITY_TYPE = session->SECURITY_TYPE;
memcpy (indicate->ACVarField.SOURCE_ADDRESS, session->PEV_MAC, sizeof (indicate->ACVarField.SOURCE_ADDRESS));
memcpy (indicate->ACVarField.RunID, session->RunID, sizeof (indicate->ACVarField.RunID));
memset (indicate->ACVarField.SOURCE_ID, 0, sizeof (indicate->ACVarField.SOURCE_ID));
memset (indicate->ACVarField.RESP_ID, 0, sizeof (indicate->ACVarField.RESP_ID));
indicate->ACVarField.NUM_SOUNDS = session->sounds;
indicate->ACVarField.ATTEN_PROFILE.NumGroups = session->NumGroups;
memcpy (indicate->ACVarField.ATTEN_PROFILE.AAG, session->AAG, session->NumGroups);
if (sendmessage (channel, message, sizeof (* indicate)) <= 0)
{
return (slac_debug (session, 1, __func__, CHANNEL_CANTSEND));
}
if (readmessage (channel, message, HOMEPLUG_MMV, (CM_ATTEN_CHAR | MMTYPE_RSP)) > 0)
{
if (! memcmp (session->RunID, response->ACVarField.RunID, sizeof (session->RunID)))
{
slac_debug (session, 0, __func__, "<-- CM_ATTEN_CHAR.RSP");
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.APPLICATION_TYPE %d", response->APPLICATION_TYPE);
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.SECURITY_TYPE %d", response->SECURITY_TYPE);
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.ACVarfield.SOURCE_ADDRESS %s", HEXSTRING (string, response->ACVarField.SOURCE_ADDRESS));
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.ACVarFIeld.RunID %s", HEXSTRING (string, response->ACVarField.RunID));
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.ACVarField.SOURCE_ID %s", HEXSTRING (string, response->ACVarField.SOURCE_ID));
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.ACVarField.RESP_ID %s", HEXSTRING (string, response->ACVarField.RESP_ID));
slac_debug (session, 0, __func__, "CM_ATTEN_CHAR.RSP.ACVarField.Result %d", response->ACVarField.Result);
}
#endif
return (0);
}
}
return (slac_debug (session, session->exit, __func__, "<-- CM_ATTEN_CHAR.RSP ?"));
}
signed Platform (struct channel * channel, const uint8_t device [])
{
struct message message;
ssize_t packetsize;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
}
* request = (struct vs_sw_ver_request *) (&message);
struct __packed vs_sw_ver_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* confirm = (struct vs_sw_ver_confirm *) (&message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
memset (&message, 0, sizeof (message));
EthernetHeader (&request->ethernet, device, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_SW_VER | MMTYPE_REQ));
if (sendpacket (channel, &message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) > 0)
{
while ((packetsize = readpacket (channel, &message, sizeof (message))) > 0)
{
if (!UnwantedMessage (&message, packetsize, 0, (VS_SW_VER | MMTYPE_CNF)))
{
chipset (confirm);
printf (" %s", chipsetname (confirm->MDEVICEID));
printf (" %s", confirm->MVERSION);
return (0);
}
}
}
return (-1);
}
signed FactoryDefaults (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_fac_defaults_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
}
* request = (struct vs_fac_defaults_request *) (message);
struct __packed vs_fac_defaults_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
}
* confirm = (struct vs_fac_defaults_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Restore Factory Defaults");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_FAC_DEFAULTS | MMTYPE_REQ));
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_FAC_DEFAULTS | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
Confirm (plc, "Restoring ...");
}
return (0);
}
signed ListLocalDevices (struct plc * plc, char const * space, char const * comma)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
ssize_t packetsize;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
}
* request = (struct vs_sw_ver_request *) (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_SW_VER | MMTYPE_REQ));
if (sendpacket (channel, message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) <= 0)
{
return (-1);
}
while ((packetsize = readpacket (channel, message, sizeof (* message))) > 0)
{
if (UnwantedMessage (message, packetsize, 0, (VS_SW_VER | MMTYPE_CNF)))
{
continue;
}
hexout (request->ethernet.OSA, sizeof (request->ethernet.OSA), HEX_EXTENDER, 0, stdout);
if ((space) && (*space))
{
printf ("%s", space);
}
}
if ((comma) && (* comma))
{
printf ("%s", comma);
}
return (0);
}
static signed Platform (struct channel * channel, const uint8_t device [])
{
extern const char * chipset [CHIPSETS+1];
struct message message;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_confirm
{
struct header_eth ethernet;
struct header_int intellon;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [INT6K_VERSTRING];
}
* confirm = (struct vs_sw_ver_confirm *) (&message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
memset (&message, 0, sizeof (message));
EthernetHeader (&message.ethernet, device, channel->host);
IntellonHeader (&message.intellon, (VS_SW_VER | MMTYPE_REQ));
if (sendpacket (channel, &message, ETHER_MIN_LEN) <= 0)
{
// error (1, errno, INT6K_CANTSEND);
return (0);
}
if (readpacket (channel, &message, sizeof (message)) <= 0)
{
// error (1, errno, INT6K_CANTREAD);
return (0);
}
if (confirm->MDEVICEID > CHIPSETS)
{
confirm->MDEVICEID = 0;
}
printf (" %s", chipset [confirm->MDEVICEID]);
printf (" %s", confirm->MVERSION);
return (0);
}
unsigned LocalDevices (struct channel const * channel, struct message * message, void * memory, size_t extent)
{
extern const byte localcast [ETHER_ADDR_LEN];
struct vs_sw_ver_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
}
* request = (struct vs_sw_ver_request *)(message);
uint8_t * origin = (uint8_t *)(memory);
uint8_t * offset = (uint8_t *)(memory);
ssize_t packetsize;
memset (memory, 0, extent);
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, localcast, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_SW_VER | MMTYPE_REQ));
if (sendpacket (channel, message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) <= 0)
{
return (0);
}
while ((packetsize = readpacket (channel, message, sizeof (* message))) > 0)
{
if (UnwantedMessage (message, packetsize, 0, (VS_SW_VER | MMTYPE_CNF)))
{
continue;
}
if (extent >= sizeof (message->ethernet.OSA))
{
memcpy (offset, message->ethernet.OSA, sizeof (message->ethernet.OSA));
offset += sizeof (message->ethernet.OSA);
extent -= sizeof (message->ethernet.OSA);
}
}
return ((unsigned)(offset - origin) / ETHER_ADDR_LEN);
}
static signed con_info (struct plc * plc, uint8_t TYPE, uint16_t CID, uint16_t TOT_BW_USED)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_con_info_req
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t REQ_TYPE;
uint32_t RSVD;
uint16_t CSPEC_VER;
uint16_t CID;
uint16_t TOT_BW_USED;
}
* request = (struct vs_con_info_req *)(message);
struct __packed vs_con_info_cnf
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t REQ_TYPE;
uint8_t MSTATUS;
uint16_t ERR_REC_CODE;
uint32_t RSVD;
uint8_t NUM_CONN;
struct conn_info CONN_INFO [64];
}
* confirm = (struct vs_con_info_cnf *)(message);
struct conn_info * conn_info = (struct conn_info*)(confirm->CONN_INFO);
struct vs_con_info_cnf * indicate = (struct vs_con_info_cnf *)(message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
int i;
Request (plc, "COQOS connection information");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_CONN_INFO | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
request->REQ_TYPE = TYPE;
request->CID = CID;
request->TOT_BW_USED = TOT_BW_USED;
request->CSPEC_VER = 0x01;
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_CONN_INFO | MMTYPE_CNF)) <= 0);
if (confirm->MSTATUS)
{
Failure (plc, "Error requesting information.");
return (-1);
}
/* BW exceeded request and "cancel all requests" do not send indicate */
if ((TYPE == CONTROL_BW) || (TYPE == CONTROL_BWC))
{
Confirm (plc, "Success");
return (0);
}
Confirm (plc, "Received confirm, waiting for indicate...");
while (ReadMME (plc, 0, (VS_CONN_INFO | MMTYPE_IND)) <= 0);
if (indicate->MSTATUS)
{
Failure (plc, "Error requesting information.");
return (-1);
}
printf ("Number of Connections: %d\n", (int)indicate->NUM_CONN);
conn_info = (struct conn_info *)(indicate->CONN_INFO);
for (i = 0; i < indicate->NUM_CONN; i++)
{
printf ("SNID: %02X ", conn_info->SNID);
printf ("CID: %04X ", conn_info->CID);
printf ("STEI: %02X ", conn_info->STEI);
printf ("DTEI: %02X ", conn_info->DTEI);
printf ("LLID: %02X ", conn_info->LLID);
printf ("CSPEC_VERSION: %04X ", conn_info->CSPECVERSION);
printf ("CONN_CAP: %02d ", conn_info->CONN_CAP);
printf ("CONN_COQOS_PRIO: %02d ", conn_info->CONN_COQOS_PRIO);
printf ("CONN_RATE: %d ", conn_info->CONN_RATE);
printf ("CONN_TTL: %d ", conn_info->CONN_TTL);
printf ("BW_USED: %d \n", conn_info->BW_USED);
conn_info++;
}
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 Identity1 (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 MCHKSUM;
uint8_t BUFFER [PLC_RECORD_SIZE];
}
* confirm = (struct vs_rd_mod_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Device Identity");
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_PIB;
request->MLENGTH = HTOLE16 (sizeof (confirm->BUFFER));
request->MOFFSET = HTOLE32 (0);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_RD_MOD | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
Confirm (plc, "-------");
pibpeek1 (confirm->BUFFER);
}
return (0);
}
signed WriteExecuteFirmware1 (struct plc * plc, unsigned module, const struct nvm_header1 * nvm_header)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_write_execute_request
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint32_t CLIENT_SESSION_ID;
uint32_t SERVER_SESSION_ID;
uint32_t FLAGS;
uint8_t ALLOWED_MEM_TYPES [8];
uint32_t TOTAL_LENGTH;
uint32_t CURR_PART_LENGTH;
uint32_t CURR_PART_OFFSET;
uint32_t START_ADDR;
uint32_t CHECKSUM;
uint8_t RESERVED2 [8];
uint8_t IMAGE [PLC_MODULE_SIZE];
}
* request = (struct vs_write_execute_request *) (message);
struct __packed vs_write_execute_confirm
{
struct ethernet_std ethernet;
struct qualcomm_std qualcomm;
uint32_t MSTATUS;
uint32_t CLIENT_SESSION_ID;
uint32_t SERVER_SESSION_ID;
uint32_t FLAGS;
uint8_t ALLOWED_MEM_TYPES [8];
uint32_t TOTAL_LENGTH;
uint32_t CURR_PART_LENGTH;
uint32_t CURR_PART_OFFSET;
uint32_t START_ADDR;
uint32_t CHECKSUM;
uint8_t RESERVED2 [8];
uint32_t CURR_PART_ABSOLUTE_ADDR;
uint32_t ABSOLUTE_START_ADDR;
}
* confirm = (struct vs_write_execute_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
unsigned action = PLC_MODULE_ABSOLUTE;
uint32_t length = PLC_MODULE_SIZE;
uint32_t offset = LE32TOH (nvm_header->IMAGEADDRESS);
uint32_t extent = LE32TOH (nvm_header->IMAGELENGTH);
Request (plc, "Write %s (%d) (%08X:%d)", plc->NVM.name, module, offset, extent);
while (extent)
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_WRITE_AND_EXECUTE_APPLET | MMTYPE_REQ));
if (length > extent)
{
Request (plc, "Start %s (%d) (%08X)", plc->NVM.name, module, LE32TOH (nvm_header->ENTRYPOINT));
length = extent;
action |= PLC_MODULE_EXECUTE;
}
if (read (plc->NVM.file, request->IMAGE, length) != (signed)(length))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
request->CLIENT_SESSION_ID = HTOLE32 (plc->cookie);
request->SERVER_SESSION_ID = HTOLE32 (0);
request->FLAGS = HTOLE32 (action);
request->ALLOWED_MEM_TYPES [0] = 1;
request->TOTAL_LENGTH = nvm_header->IMAGELENGTH;
request->CURR_PART_LENGTH = HTOLE32 (length);
request->CURR_PART_OFFSET = HTOLE32 (offset);
request->START_ADDR = nvm_header->ENTRYPOINT;
request->CHECKSUM = nvm_header->IMAGECHECKSUM;
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_WRITE_AND_EXECUTE_APPLET | MMTYPE_CNF)) <= 0)
{
error ((plc->flags & PLC_BAILOUT), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
if (LE32TOH (confirm->CURR_PART_LENGTH) != length)
{
error ((plc->flags & PLC_BAILOUT), 0, PLC_ERR_LENGTH);
return (-1);
}
if (LE32TOH (confirm->CURR_PART_OFFSET) != offset)
{
error ((plc->flags & PLC_BAILOUT), 0, PLC_ERR_OFFSET);
return (-1);
}
offset += length;
extent -= length;
}
return (0);
}
signed PLCNetworkInfo (struct plc * plc)
{
signed status;
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* request = (struct vs_sw_ver_request *) (message);
struct __packed vs_sw_ver_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* confirm = (struct vs_sw_ver_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_SW_VER | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_SW_VER | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, "Device will not start");
return (-1);
}
chipset (confirm);
if ((plc->hardwareID = confirm->MDEVICEID) < CHIPSET_AR7400)
{
status = NetInfo1 (plc);
}
else
{
status = NetInfo2 (plc);
}
return (status);
}
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);
}
static signed Diagnostics (struct plc * plc)
{
char version [PLC_VERSION_STRING];
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_sw_ver_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* request = (struct vs_sw_ver_request *) (message);
struct __packed vs_sw_ver_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t MDEVICEID;
uint8_t MVERLENGTH;
char MVERSION [PLC_VERSION_STRING];
}
* confirm = (struct vs_sw_ver_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_SW_VER | MMTYPE_REQ));
plc->packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_SW_VER | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
memcpy (version, confirm->MVERSION, sizeof (version));
if (plc->action == INT6KLOG_FMT_XML)
{
printf ("<?xml version='1.0' encoding='utf-8' standalone='yes'?>");
printf ("<Diagnostics>");
PrintWatchdogReport (plc, version);
PrintCheckpointReport (plc, version);
printf ("</Diagnostics>\n");
return (0);
}
if (plc->action == INT6KLOG_FMT_RAW)
{
PrintRawWatchdogReport (plc);
return (0);
}
return (0);
}
signed SetNMK (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_set_key_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t EKS;
uint8_t NMK [HPAVKEY_NMK_LEN];
uint8_t PEKS;
uint8_t RDA [ETHER_ADDR_LEN];
uint8_t DAK [HPAVKEY_DAK_LEN];
}
* request = (struct vs_set_key_request *) (message);
struct __packed vs_set_key_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
}
* confirm = (struct vs_set_key_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_SET_KEY | MMTYPE_REQ));
plc->packetsize = sizeof (struct vs_set_key_request);
request->EKS = 0x01;
memcpy (request->NMK, plc->NMK, sizeof (request->NMK));
if (_anyset (plc->flags, PLC_SETREMOTEKEY))
{
Request (plc, "Set Remote Network Membership Key");
memcpy (request->RDA, plc->RDA, sizeof (request->RDA));
memcpy (request->DAK, plc->DAK, sizeof (request->DAK));
request->PEKS = 0x00;
}
else
{
Request (plc, "Set Local Network Membership Key");
memset (request->RDA, 0, sizeof (request->RDA));
memset (request->DAK, 0, sizeof (request->DAK));
request->PEKS = 0x0F;
}
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_SET_KEY | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
Confirm (plc, "Setting ...");
return (0);
}
signed SetProperty (struct plc * plc, struct plcproperty * plcproperty)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_set_property_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t COOKIE;
uint8_t OPTION;
uint8_t RESERVED [3];
uint32_t PROP_VERSION;
uint32_t PROP_NUMBER;
uint32_t DATA_LENGTH;
uint8_t DATA_BUFFER [256];
}
* request = (struct vs_set_property_request *) (message);
struct __packed vs_set_property_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t MSTATUS;
uint32_t COOKIE;
}
* confirm = (struct vs_set_property_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
Request (plc, "Set Property");
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_SET_PROPERTY | MMTYPE_REQ));
request->COOKIE = HTOLE32 (plc->cookie);
request->OPTION = plcproperty->PROP_OPTION;
request->PROP_VERSION = HTOLE32 (plcproperty->PROP_VERSION);
request->PROP_NUMBER = HTOLE32 (plcproperty->PROP_NUMBER);
request->DATA_LENGTH = HTOLE32 (plcproperty->DATA_LENGTH);
memcpy (&request->DATA_BUFFER, &plcproperty->DATA_BUFFER, plcproperty->DATA_LENGTH);
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
while (ReadMME (plc, 0, (VS_SET_PROPERTY | MMTYPE_CNF)) > 0)
{
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
continue;
}
}
return (0);
}
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);
}
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);
}
signed WriteFirmware1 (struct plc * plc, unsigned module, const struct nvm_header1 * nvm_header)
{
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_mem_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint32_t MOFFSET;
uint32_t MLENGTH;
uint8_t BUFFER [PLC_RECORD_SIZE];
}
* request = (struct vs_wr_mem_request *) (message);
struct __packed vs_wr_mem_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint32_t MOFFSET;
uint32_t MLENGTH;
}
* confirm = (struct vs_wr_mem_confirm *) (message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
uint32_t length = PLC_RECORD_SIZE;
uint32_t offset = LE32TOH (nvm_header->IMAGEADDRESS);
uint32_t extent = LE32TOH (nvm_header->IMAGELENGTH);
Request (plc, "Write %s (%d) (%08X:%d)", plc->NVM.name, module, offset, extent);
while (extent)
{
memset (message, 0, sizeof (* message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_WR_MEM | MMTYPE_REQ));
if (length > extent)
{
length = extent;
}
if (read (plc->NVM.file, request->BUFFER, length) != (signed)(length))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
request->MLENGTH = HTOLE32 (length);
request->MOFFSET = HTOLE32 (offset);
plc->packetsize = sizeof (* request);
if (SendMME (plc) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
return (-1);
}
if (ReadMME (plc, 0, (VS_WR_MEM | MMTYPE_CNF)) <= 0)
{
error (PLC_EXIT (plc), errno, CHANNEL_CANTREAD);
return (-1);
}
if (confirm->MSTATUS)
{
Failure (plc, PLC_WONTDOIT);
return (-1);
}
if (LE32TOH (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);
}
