void SessionTask ()
{
extern struct session session;
extern struct channel channel;
extern struct fileinfo pib;
extern struct fileinfo nvm;
CGILocalPLD ();
if (!strcmp (session.action, ACTION_SOURCE))
{
closechannel (&channel);
channel.name = session.source;
openchannel (&channel);
CGILocalPLD ();
}
else if (!strcmp (session.action, ACTION_DEVICE))
{
}
else if (!strcmp (session.action, ACTION_NETWORK))
{
CGISetKey ();
}
else if (!strcmp (session.action, ACTION_PRIORITIZE))
{
status (1, ENOSYS, "This is demonstration software.");
}
else if (!strcmp (session.action, ACTION_CONFIGURE))
{
if ((!pib.data) || (!pib.size))
{
status (1, ECANCELED, "No PIB file selected");
}
CGIWriteMOD (VS_MODULE_PIB, pib.data, pib.size);
CGIFlashMOD (VS_MODULE_PIB);
memset (&pib, 0, sizeof (pib));
memset (&nvm, 0, sizeof (nvm));
}
else if (!strcmp (session.action, ACTION_UPGRADE))
{
if ((!pib.data) && (!pib.size))
{
status (1, ECANCELED, "No PIB file selected");
}
if ((!nvm.data) && (!nvm.size))
{
status (1, ECANCELED, "No NVM file selected");
}
CGIWriteMOD (VS_MODULE_PIB, pib.data, pib.size);
CGIWriteMOD (VS_MODULE_MAC, nvm.data, nvm.size);
CGIFlashMOD (VS_MODULE_MAC|VS_MODULE_PIB);
memset (&pib, 0, sizeof (pib));
memset (&nvm, 0, sizeof (nvm));
}
else if (!strcmp (session.action, ACTION_DEFAULT))
{
CGIRestore ();
}
memset (session.action, 0, sizeof (session.action));
return;
}
/* Notification that our channel open request failed */
void recv_msg_channel_open_failure() {
unsigned int chan;
struct Channel * channel;
chan = buf_getbyte(ses.payload);
channel = getchannel(chan);
if (channel == NULL) {
dropbear_exit("Unknown channel");
}
closechannel(channel);
}
/* Clean up channels, freeing allocated memory */
void chancleanup() {
unsigned int i;
TRACE(("enter chancleanup"));
for (i = 0; i < ses.chansize; i++) {
if (ses.channels[i] != NULL) {
TRACE(("channel %d closing", i));
closechannel(ses.channels[i]);
}
}
m_free(ses.channels);
TRACE(("leave chancleanup"));
}
static void enumerate (struct channel * channel, struct nic nic [], unsigned size)
{
extern const byte localcast [ETHER_ADDR_LEN];
for (; size--; nic++)
{
byte memory [ETHER_ADDR_LEN];
char string [ETHER_ADDR_LEN * 3];
memset (memory, 0x00, sizeof (memory));
if (!memcmp (memory, nic->ethernet, sizeof (memory)))
{
continue;
}
memset (memory, 0xFF, sizeof (memory));
if (!memcmp (memory, nic->ethernet, sizeof (memory)))
{
continue;
}
#if defined (WINPCAP) || defined (LIBPCAP)
printf (" %d", nic->ifindex);
#elif defined (__linux__) || defined (__OpenBSD__) || defined (__APPLE__)
printf (" %s", nic->ifname);
#else
#error "Unknown environment"
#endif
printf (" %s", hexstring (string, sizeof (string), nic->ethernet, sizeof (nic->ethernet)));
printf (" %s", decstring (string, sizeof (string), nic->internet, sizeof (nic->internet)));
#if 0
printf (" %s", nic->ifname);
printf (" %s", nic->ifdesc);
#endif
channel->ifname = nic->ifname;
openchannel (channel);
Platform (channel, localcast);
closechannel (channel);
printf ("\n");
}
return;
}
/* Handle channel closure(), respond in kind and close the channels */
void recv_msg_channel_close() {
unsigned int chan;
struct Channel * channel;
TRACE(("enter recv_msg_channel_close"));
chan = buf_getint(ses.payload);
TRACE(("close channel = %d", chan));
channel = getchannel(chan);
if (channel == NULL) {
/* disconnect ? */
dropbear_exit("Close for unknown channel");
}
if (!channel->sentclosed) {
send_msg_channel_close(channel);
}
closechannel(channel);
TRACE(("leave recv_msg_channel_close"));
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ei:qrst:T:vV:",
"action operand condition [...] control volatility [device] [...]\n\n where a condition is: field operator value",
"Qualcomm Atheros Stream MakeRules Utility",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"r\tread rules from device",
"s\tdisplay symbol tables",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"T x\tinserted vlan tag is x [" LITERAL (PLCRULE_VLAN_TAG) "]",
"v\tverbose mode",
"V n\tcspec version is n [" LITERAL (PLCRULE_CSPEC_VERSION) "]",
(char const *) (0)
};
#include "../plc/plc.c"
struct cspec cspec;
struct MMERule rule;
signed c;
memset (& rule, 0, sizeof (rule));
memset (& cspec, 0, sizeof (cspec));
cspec.VLAN_TAG = PLCRULE_VLAN_TAG;
cspec.CSPEC_VERSION = PLCRULE_CSPEC_VERSION;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'r':
_setbits (plc.flags, PLC_ANALYSE);
break;
case 's':
printf ("\n");
printf (" Controls are ");
codelist (controls, SIZEOF (controls), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Volatilities are ");
codelist (volatilities, SIZEOF (volatilities), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Actions are ");
codelist (actions, SIZEOF (actions), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Operands are ");
codelist (operands, SIZEOF (operands), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Fields are ");
codelist (fields, SIZEOF (fields), COMMA, QUOTE, stdout);
printf (".\n");
printf (" Operators are ");
codelist (operators, SIZEOF (operators), COMMA, QUOTE, stdout);
printf (".\n");
printf (" States are ");
codelist (states, SIZEOF (states), COMMA, QUOTE, stdout);
printf (".\n");
printf ("\n");
return (0);
case 't':
channel.timeout = (signed) (uintspec (optarg, 0, UINT_MAX));
break;
case 'T':
cspec.VLAN_TAG = (uint32_t) (basespec (optarg, 16, sizeof (cspec.VLAN_TAG)));
cspec.VLAN_TAG = htonl (cspec.VLAN_TAG);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'V':
cspec.CSPEC_VERSION = (uint16_t) (basespec (optarg, 10, sizeof (cspec.CSPEC_VERSION)));
cspec.CSPEC_VERSION = HTOLE16 (cspec.CSPEC_VERSION);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (plc.flags, PLC_ANALYSE))
{
if (ParseRule (& argc, & argv, & rule, & cspec) == -1)
{
error (1, 0, "invalid rule");
}
}
openchannel (& channel);
if (! (plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (! argc)
{
if (_anyset (plc.flags, PLC_ANALYSE))
{
ReadRules (& plc);
}
else
{
MakeRule (& plc, & rule);
}
}
while ((argc) && (* argv))
{
if (! hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
if (_anyset (plc.flags, PLC_ANALYSE))
{
ReadRules (& plc);
}
else
{
MakeRule (& plc, & rule);
}
argc--;
argv++;
}
free (plc.message);
closechannel (& channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ei:qv",
"cid",
"CoQos Stream Utility",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"v\tverbose mode",
(char const *) (0)
};
#include "../plc/plc.c"
uint16_t cid;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (!argc)
{
error (1, ECANCELED, "Missing CID");
}
if (!hexencode ((uint8_t *)(&cid), sizeof (cid), * argv++))
{
error (1, EINVAL, "CID=[%s]", *--argv);
}
cid = htons (cid);
argc--;
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
rel_conn (&plc, cid);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
rel_conn (&plc, cid);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"cCef:ri:qvz:",
"device [device] [...] [> stdout]",
"Qualcomm Atheros INT6x00 Log Retrieval Utility",
"c\tclear watchdog and checkpoint reports",
"C\tcustom watchdog report",
"e\tredirect stderr to stdout",
"f s\tprint Watchdog Report in format (s) [xml]",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"r\tread ",
"v\tverbose mode",
(char const *) (0)
};
#include "../plc/plc.c"
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
plc.readaction = 0;
plc.action = INT6KLOG_FMT_XML;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'C':
_setbits (plc.readaction, WD_ACTION_CUSTOM);
break;
case 'c':
_setbits (plc.readaction, WD_ACTION_CLEAR);
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'f':
if ((c = lookup (optarg, formats, SIZEOF (formats))) == -1)
{
assist (optarg, "format", formats, SIZEOF (formats));
}
plc.action = (uint8_t)(c);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'r':
_setbits (plc.readaction, WD_ACTION_READ);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'z':
plc.readaction = (uint8_t)(uintspec (optarg, 0, 255));
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
{
if (plc.rpt.file != -1)
{
error (1, ECANCELED, PLC_NODEVICE);
}
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
#ifdef WIN32
if (plc.action == INT6KLOG_FMT_RAW)
{
setmode (STDOUT_FILENO, O_BINARY);
}
#endif
if (!argc)
{
Diagnostics (&plc);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
Diagnostics (&plc);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"eFi:N:p:P:qS:t:vx",
"-N file -P file [device] [device] [...]",
"Qualcomm Atheros Panther/Lynx Powerline Device Bootstrapper",
"e\tredirect stderr to stdout",
"F[F]\tFlash [Force] non-volatile memory after boot",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" OPTSTR (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" OPTSTR (CHANNEL_ETHDEVICE) "]",
#endif
"N f\tfirmware file is (f)",
"P f\tparameter file is (f)",
"q\tquiet mode",
"S f\tsoftloader file is (f)",
"t n\tread timeout is (n) milliseconds [" OPTSTR (CHANNEL_TIMEOUT) "]",
"v\tverbose mode",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
char firmware [PLC_VERSION_STRING];
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'F':
_setbits (plc.module, (VS_MODULE_MAC | VS_MODULE_PIB));
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
_setbits (plc.module, VS_MODULE_FORCE);
}
_setbits (plc.flags, PLC_FLASH_DEVICE);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'N':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.NVM.file = open (plc.NVM.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.NVM.name);
}
if (nvmfile2 (&plc.NVM))
{
error (1, errno, "Bad NVM file: %s", plc.NVM.name);
}
_setbits (plc.flags, PLC_WRITE_MAC);
break;
case 'P':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.PIB.file = open (plc.PIB.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.PIB.name);
}
if (pibfile2 (&plc.PIB))
{
error (1, errno, "Bad PIB file: %s", plc.PIB.name);
}
_setbits (plc.flags, PLC_WRITE_PIB);
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'S':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.CFG.file = open (plc.CFG.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.CFG.name);
}
if (nvmfile2 (&plc.CFG))
{
error (1, errno, "Bad NVM file: %s", plc.CFG.name);
}
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ENOTSUP, ERROR_TOOMANY);
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (WaitForStart (&plc, firmware, sizeof (firmware)))
{
Failure (&plc, PLC_NODETECT);
exit (1);
}
if (plc.hardwareID < CHIPSET_INT6400)
{
Failure (&plc, "Device must be %s or later; Use program int6kboot instead.", chipsetname (CHIPSET_INT6400));
exit (1);
}
if (strcmp (firmware, "BootLoader"))
{
Failure (&plc, "Bootloader must be running");
exit (1);
}
if (plc.PIB.file == -1)
{
error (1, ECANCELED, "No Parameter file named");
}
if (plc.NVM.file == -1)
{
error (1, ECANCELED, "No Firmware file named");
}
if (plc.CFG.file == -1)
{
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
error (1, ECANCELED, "No Softloader file named");
}
}
if (!InitDevice2 (&plc))
{
if (!BootDevice2 (&plc))
{
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
FlashDevice2 (&plc);
}
}
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, const char * argv [])
{
extern struct channel channel;
static const char *optv [] =
{
"i:qv",
PUTOPTV_S_DIVINE,
"HomePlug AV Packet Listener",
#if defined (WINPCAP) || defined (LIBPCAP)
"i s\tuse host interface s [" CHANNEL_ETHDEVICE "]",
#else
"i n\tuse host interface n [2]",
#endif
"q\tsuppress normal output",
"v\tverbose messages on stdout",
(const char *) (0)
};
flag_t flags = (flag_t)(0);
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.id = atoi (getenv (PLCDEVICE));
#else
channel.name = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
opterr = 1;
optmin = 0;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'i':
#if defined (WIN32)
channel.id = atoi (optarg);
#else
channel.name = optarg;
#endif
break;
case 'q':
_setbits (flags, HPAV_SILENCE);
break;
case 'v':
_setbits (flags, HPAV_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
#ifndef WIN32
if (geteuid ())
{
error (1, EPERM, INT6K_NEEDROOT);
}
#endif
openchannel (&channel);
function (&channel, flags);
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"cCdi:p:qs:t:vx",
"",
"Qualcomm Atheros Electric Vehicle Supply Equipment Emulator",
"c\tprint template configuration file on stdout",
"C\tstop on count mismatch",
"d\tdisplay debug information",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"p s\tconfiguration profile is (s) [" LITERAL (PROFILE) "]",
"s s\tconfiguration section is (s) [" LITERAL (SECTION) "]",
"q\tquiet mode",
"t n\tread timeout is (n) milliseconds [" LITERAL (SLAC_TIMEOUT) "]",
"v\tverbose mode",
"x\texit on error",
(char const *) (0)
};
struct session session;
struct message message;
char const * profile = PROFILE;
char const * section = SECTION;
signed c;
memset (& session, 0, sizeof (session));
memset (& message, 0, sizeof (message));
channel.timeout = SLAC_TIMEOUT;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'c':
configure ();
return (0);
case 'C':
_setbits (session.flags, SLAC_COMPARE);
break;
case 'd':
_setbits (session.flags, (SLAC_VERBOSE | SLAC_SESSION));
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'p':
profile = optarg;
break;
case 's':
section = optarg;
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (session.flags, SLAC_SILENCE);
break;
case 't':
channel.timeout = (signed) (uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
case 'x':
session.exit = session.exit? 0: 1;
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
desuid ();
if (argc)
{
slac_debug (& session, 1, __func__, ERROR_TOOMANY);
}
initialize (& session, profile, section);
identifier (& session, & channel);
if (evse_cm_set_key (& session, & channel, & message))
{
slac_debug (& session, 1, __func__, "Can't set key.");
}
sleep (session.settletime);
while (session.state)
{
if (session.state == EVSE_STATE_UNOCCUPIED)
{
UnoccupiedState (& session, & channel, & message);
continue;
}
if (session.state == EVSE_STATE_UNMATCHED)
{
UnmatchedState (& session, & channel, & message);
continue;
}
if (session.state == EVSE_STATE_MATCHED)
{
MatchedState (& session, & channel, & message);
continue;
}
slac_debug (& session, 1, __func__, "Illegal state!");
}
closechannel (& channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"b:d:e:hi:p:t:v",
"",
"Ethernet Frame Blast Utility",
"b n\tbinary byte value is (n) [" LITERAL (EFBU_BINARY) "]",
"d x\treplace destination address with (x)",
"e x\tethertype is (x) [" LITERAL (EFBU_ETHERTYPE) "]",
"h\treplace source address with host address",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"t n\ttransmit for (n) milliseconds [" LITERAL (EFBU_TIMER) "]",
"p n\tpause (n) milliseconds between frames [" LITERAL (EFBU_PAUSE) "]",
"v\tverbose messages",
(char const *) (0)
};
byte buffer [ETHER_MAX_LEN];
byte binary = EFBU_BINARY;
unsigned timer = EFBU_TIMER;
unsigned pause = EFBU_PAUSE;
signed c;
if (getenv (EFBU_INTERFACE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (EFBU_INTERFACE));
#else
channel.ifname = strdup (getenv (EFBU_INTERFACE));
#endif
}
optind = 1;
memset (channel.peer, 0xFF, sizeof (channel.peer));
memset (channel.host, 0xFF, sizeof (channel.host));
channel.type = EFBU_ETHERTYPE;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'b':
binary = (uint8_t)(uintspec (optarg, 0, 255));
break;
case 'd':
_setbits (channel.flags, CHANNEL_UPDATE_TARGET);
if (!hexencode (channel.peer, sizeof (channel.peer), optarg))
{
error (1, errno, "%s", optarg);
}
break;
case 'e':
channel.type = (uint16_t)(basespec (optarg, 16, sizeof (channel.type)));
break;
case 'h':
_setbits (channel.flags, CHANNEL_UPDATE_SOURCE);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'p':
pause = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 't':
timer = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ECANCELED, ERROR_TOOMANY);
}
openchannel (&channel);
function (&channel, buffer, sizeof (buffer), binary, timer, pause);
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
extern const struct _term_ devices [];
static char const * optv [] =
{
"i:bnqrsv",
"device [device] [...] [> stdout]",
"Qualcomm Atheros Device Statistics Utility",
"b\tprint bridge devices; exclude remote devices",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"n\tappend newline to output",
"q\tquiet mode",
"r\tprint remote devices; exclude bridge devices",
"s\tprint newlines instead of spaces",
"v\tverbose mode",
(char const *) (0)
};
#include "../plc/plc.c"
char const * space = " ";
char const * comma = "\0";
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'b':
_setbits (plc.flags, PLC_BRIDGE_LIST);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'n':
comma = "\n";
break;
case 'r':
_setbits (plc.flags, PLC_REMOTE_LIST);
break;
case 's':
space = "\n";
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (plc.flags, (PLC_BRIDGE_LIST|PLC_REMOTE_LIST)))
{
_setbits (plc.flags, (PLC_BRIDGE_LIST|PLC_REMOTE_LIST));
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
ListLocalDevices (&plc, space, comma);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
ListRemoteDevices1 (&plc, space, comma);
argc--;
argv++;
}
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"d:e:hi:l:p:t:vw:",
PUTOPTV_S_FUNNEL,
"Ethernet Frame Send Utility",
"d x\treplace destination address with (x)",
"e x\techo return frames having ethertype (x) [" LITERAL (EFSU_ETHERTYPE) "]",
"h\treplace source address with host address",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"l n\trepeat file sequence (n) times [" LITERAL (EFSU_LOOP) "]",
"p n\twait (n) seconds between files [" LITERAL (EFSU_PAUSE) "]",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"v\tverbose messages",
"w n\twait (n) seconds between loops [" LITERAL (EFSU_DELAY) "]",
(char const *) (0)
};
unsigned pause = EFSU_PAUSE;
unsigned delay = EFSU_DELAY;
unsigned loop = EFSU_LOOP;
signed c;
channel.type = EFSU_ETHERTYPE;
if (getenv (EFSU_INTERFACE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (EFSU_INTERFACE));
#else
channel.ifname = strdup (getenv (EFSU_INTERFACE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'd':
_setbits (channel.flags, CHANNEL_UPDATE_TARGET);
if (!hexencode (channel.peer, sizeof (channel.peer), optarg))
{
error (1, errno, "%s", optarg);
}
break;
case 'e':
_setbits (channel.flags, CHANNEL_LISTEN);
channel.type = (uint16_t)(basespec (synonym (optarg, protocols, SIZEOF (protocols)), 16, sizeof (channel.type)));
break;
case 'h':
_setbits (channel.flags, CHANNEL_UPDATE_SOURCE);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'l':
loop = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'p':
pause = (unsigned)(uintspec (optarg, 0, 1200));
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
case 'w':
delay = (unsigned)(uintspec (optarg, 0, 1200));
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
while (loop--)
{
iterate (argc, argv, &channel, pause);
if (loop)
{
sleep (delay);
}
}
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"Cd:ei:l:mp:qs:tvw:",
"device [device] [...] [> stdout]",
"Qualcomm Atheros AR7x00 Link Statistics",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"C\tclear statistics without reading using VS_LNK_STATS",
"d n\tdirection (0=tx, 1=rx, 2=both) for VS_LNK_STATS",
"e\tredirect stderr to stdout",
"l n\tloop n times [" LITERAL (AMPSTAT_LOOP) "]",
"s n\tLink ID for VS_LNK_STATS (see Programmer's Guide)",
"m\tprint network membership information using VS_NW_INFO",
"p x\tpeer node address for options -s",
"q\tquiet mode",
"t\tprint network topology using VS_NW_INFO with VS_SW_VER",
"v\tverbose mode",
"w n\twait n seconds [" LITERAL (AMPSTAT_WAIT) "]",
(char const *) (0)
};
#include "../plc/plc.c"
signed loop = AMPSTAT_LOOP;
signed wait = AMPSTAT_WAIT;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
plc.pushbutton = 0;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'C':
_setbits (plc.flags, PLC_LINK_STATS);
plc.pushbutton = 1;
break;
case 'd':
_setbits (plc.flags, PLC_LINK_STATS);
plc.module = (uint8_t)(uintspec (synonym (optarg, directions, SIZEOF (directions)), 0, UCHAR_MAX));
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'm':
_setbits (plc.flags, PLC_NETWORK);
break;
case 'p':
_setbits (plc.flags, PLC_LINK_STATS);
if (!hexencode (plc.RDA, sizeof (plc.RDA), (char const *)(optarg)))
{
error (1, errno, PLC_BAD_MAC, optarg);
}
break;
case 'l':
loop = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 's':
_setbits (plc.flags, PLC_LINK_STATS);
plc.action = (uint8_t)(uintspec (synonym (optarg, linkids, SIZEOF (linkids)), 0, UCHAR_MAX));
break;
case 't':
_setbits (plc.flags, PLC_ANALYSE);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'w':
wait = (unsigned)(uintspec (optarg, 0, 3600));
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
manager (&plc, loop, wait);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
manager (&plc, loop, wait);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ehi:p:qsvx",
"node peer [> stdout]",
"Qualcomm Atheros Thunderbolt/Lightning Tone Map Dump",
"e\tredirect stderr to stdout",
"h\tprint mean-square histogram",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" OPTSTR (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" OPTSTR (CHANNEL_ETHDEVICE) "]",
#endif
"p n\tcoupling [" OPTSTR (AMPTONE_COUPLING) "]",
"q\tquiet mode",
"s\tcompute signal-to-noise and bits-per-carrier ratios",
"v\tverbose mode",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
signed (* function) (struct plc *) = ToneMaps2;
signed c;
plc.action = AMPTONE_COUPLING;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'p':
plc.action = (unsigned)(uintspec (synonym (optarg, couple, SIZEOF (couple)), 0, UCHAR_MAX));
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'h':
_setbits (plc.flags, PLC_GRAPH);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 's':
_setbits (plc.flags, PLC_ANALYSE);
function = SignalToNoise2;
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (!argc || !argv)
{
error (1, ECANCELED, "No node address given");
}
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
argc--;
argv++;
if (!argc || !argv)
{
error (1, ECANCELED, "No peer address given");
}
if (!hexencode (plc.RDA, sizeof (plc.RDA), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
argc--;
argv++;
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
function (&plc);
free (plc.message);
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
struct message message;
static char const * optv [] =
{
"i:qt:v",
PUTOPTV_S_DIVINE,
"Qualcomm Atheros HomePlug AV Packet Monitor",
#if defined (WINPCAP)
"i s\thost interface is (s) [" CHANNEL_ETHDEVICE "]",
#else
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#endif
"q\tsuppress normal output",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"v\tverbose messages on stdout",
(char const *) (0)
};
flag_t flags = (flag_t)(0);
signed length;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'i':
#if defined (WIN32)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (flags, HPAV_SILENCE);
break;
case 't':
channel.timeout = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (flags, HPAV_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
while ((length = readpacket (&channel, &message, sizeof (message))) >= 0)
{
if (length > 0)
{
if (_allclr (flags, HPAV_SILENCE))
{
MMEPeek (&message, length, stdout);
}
if (_anyset (flags, HPAV_VERBOSE))
{
hexdump (&message, 0, length, stdout);
}
}
}
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"Fi:n:N:p:P:qt:vx",
"-N file -P file [-n file] [-p file]",
"Qualcomm Atheros INT6400 Host Emulator",
"F[F]\tflash (force) NVRAM using VS_MOD_NVM",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"n f\tread NVM from device into file using VS_RD_MOD",
"N f\twrite NVM file to device using VS_WR_MEM",
"p f\tread PIB from device into file using VS_RD_MOD",
"P f\twrite PIB file to device using VS_WR_MEM",
"q\tquiet mode",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"v\tverbose mode",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
}
}
openchannel (&channel);
desuid ();
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'F':
_setbits (plc.module, (VS_MODULE_MAC | VS_MODULE_PIB));
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
_setbits (plc.module, VS_MODULE_FORCE);
}
_setbits (plc.flags, PLC_FLASH_DEVICE);
break;
case 'N':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.NVM.file = open (plc.NVM.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.NVM.name);
}
if (nvmfile1 (&plc.NVM))
{
error (1, errno, "Bad firmware file: %s", plc.NVM.name);
}
_setbits (plc.flags, PLC_WRITE_MAC);
break;
case 'n':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.nvm.file = open (plc.nvm.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.nvm.name);
}
break;
case 'P':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.PIB.file = open (plc.PIB.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.PIB.name);
}
if (pibfile1 (&plc.PIB))
{
error (1, errno, "Bad parameter file: %s", plc.PIB.name);
}
_setbits (plc.flags, PLC_WRITE_PIB);
break;
case 'p':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.pib.file = open (plc.pib.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.pib.name);
}
break;
case 'q':
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ENOTSUP, ERROR_TOOMANY);
}
if (plc.NVM.file == -1)
{
error (1, ECANCELED, "No host NVM file named");
}
if (plc.PIB.file == -1)
{
error (1, ECANCELED, "No host PIB file named");
}
if (plc.nvm.file == -1)
{
if ((plc.nvm.file = open (plc.nvm.name = NEWNVM, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.nvm.name);
}
}
if (plc.pib.file == -1)
{
if ((plc.pib.file = open (plc.pib.name = NEWPIB, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.pib.name);
}
}
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
function (&plc);
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
extern void terminate (signo_t);
static char const * optv [] =
{
"dFi:n:N:p:P:qS:t:vw:x",
"-N file -P file [-S file]",
"Qualcomm Atheros Panther/Lynx PLC Host Daemon",
"d\texecute in background as daemon",
"F [F]\tflash [force] non-volatile memory",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"n f\tread firmware from device into file (f)",
"N f\tfirmware file is (f)",
"p f\tread parameters from device into file (f)",
"P f\tparameter file is (f)",
"q\tquiet mode",
"S f\tsoftloader file is (f)",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"v\tverbose mode",
"w n\twakeup every (n) seconds [" LITERAL (PLC_LONGTIME) "]",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
struct sigaction sa;
char const * socketname = SOCKETNAME;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
plc.timer = PLC_LONGTIME;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'd':
_setbits (plc.flags, PLC_DAEMON);
break;
case 'F':
_setbits (plc.module, (VS_MODULE_MAC | VS_MODULE_PIB));
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
_setbits (plc.module, VS_MODULE_FORCE);
}
_setbits (plc.flags, PLC_FLASH_DEVICE);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'N':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.NVM.file = open (plc.NVM.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.NVM.name);
}
if (nvmfile2 (&plc.NVM))
{
error (1, errno, "Bad firmware file: %s", plc.NVM.name);
}
_setbits (plc.flags, PLC_WRITE_MAC);
break;
case 'n':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.nvm.file = open (plc.nvm.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.nvm.name);
}
break;
case 'P':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.PIB.file = open (plc.PIB.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.PIB.name);
}
if (pibfile2 (&plc.PIB))
{
error (1, errno, "Bad parameter file: %s", plc.PIB.name);
}
_setbits (plc.flags, PLC_WRITE_PIB);
break;
case 'p':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.pib.file = open (plc.pib.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.pib.name);
}
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'S':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.CFG.file = open (plc.CFG.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.CFG.name);
}
if (nvmfile2 (&plc.CFG))
{
error (1, errno, "Bad firmware file: %s", plc.CFG.name);
}
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'w':
plc.timer = (unsigned)(uintspec (optarg, 1, 3600));
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ENOTSUP, ERROR_TOOMANY);
}
if (plc.NVM.file == -1)
{
error (1, ECANCELED, "No host NVM file named");
}
if (plc.PIB.file == -1)
{
error (1, ECANCELED, "No host PIB file named");
}
if (plc.CFG.file == -1)
{
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
error (1, ECANCELED, "No Softloader file named");
}
}
if (plc.nvm.file == -1)
{
if ((plc.nvm.file = open (plc.nvm.name = NEWNVM, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.nvm.name);
}
}
if (plc.pib.file == -1)
{
if ((plc.pib.file = open (plc.pib.name = NEWPIB, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.pib.name);
}
}
#ifndef WIN32
if (_anyset (plc.flags, PLC_DAEMON))
{
pid_t pid = fork ();
if (pid < 0)
{
error (1, errno, "Can't start daemon");
}
if (pid > 0)
{
exit (0);
}
}
memset (&sa, 0, sizeof (struct sigaction));
sa.sa_handler = terminate;
sigaction (SIGTERM, &sa, (struct sigaction *)(0));
sigaction (SIGQUIT, &sa, (struct sigaction *)(0));
sigaction (SIGTSTP, &sa, (struct sigaction *)(0));
sigaction (SIGINT, &sa, (struct sigaction *)(0));
sigaction (SIGHUP, &sa, (struct sigaction *)(0));
#endif
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
function (&plc, socketname);
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ACD:ef:i:l:M:o:qRS:t:vxz:",
"device [device] [...] [> stdout]",
"Qualcomm Atheros VLANID Forward Configuration Manager",
"A\tadd VLAN ID of multiple slaves to memory",
"C\tcommit configuration to flash memory",
"D x\tset default VLAN ID",
"e\tredirect stderr to stdout",
"f s\tread VLANIDS from file (s)",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"l n\tdata length in bytes [" LITERAL (PLCFWD_LENGTH) "]",
"M n\tenable VLANID forwarding on the master",
"o x\tdata offset in bytes [" LITERAL (PLCFWD_OFFSET) "]",
"q\tquiet mode",
"R\tremove VLAN ID of multiple slaves from memory",
"S n\tenable VLANID forwarding on all slaves",
"t n\ttimeout is (n) millisecond [" LITERAL (CHANNEL_TIMEOUT) "]",
"v\tverbose mode",
"x\texit on error",
"z s\tslavespec",
(char const *) (0)
};
#include "../plc/plc.c"
struct item list [128];
unsigned size = sizeof (list) / sizeof (struct item);
unsigned items = 0;
uint32_t offset = 0;
uint32_t length = 0;
signed c;
memset (&list, 0, sizeof (list));
if (getenv (PLCDEVICE))
{
channel.ifname = strdup (getenv (PLCDEVICE));
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'A':
plc.action = PLCFWD_ADD;
break;
case 'C':
plc.action = PLCFWD_STO;
break;
case 'D':
plc.action = PLCFWD_SET;
list [0].VLANID [0] = (uint16_t)(basespec (optarg, 10, sizeof (uint16_t)));
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'f':
if (!freopen (optarg, "rb", stdin))
{
error (1, errno, "%s", optarg);
}
items += readlist (&list [items], size - items);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'M':
plc.action = PLCFWD_CTL;
plc.module = (uint8_t)(uintspec (synonym (optarg, states, STATES), 0, UCHAR_MAX));
break;
case 'l':
length = (uint32_t) (basespec (optarg, 10, sizeof (length)));
break;
case 'o':
offset = (uint32_t) (basespec (optarg, 10, sizeof (offset)));
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'R':
plc.action = PLCFWD_REM;
break;
case 'S':
plc.action = PLCFWD_CTL;
plc.pushbutton = (uint8_t)(uintspec (synonym (optarg, states, STATES), 0, UCHAR_MAX));
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
case 'z':
readitem (&list [items++], optarg);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
#if 0
showlist (list, items);
#endif
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
function (&plc, offset, length, list, items);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
function (&plc, offset, length, list, items);
argv++;
argc--;
}
free (plc.message);
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
extern struct key const keys [];
static char const * optv [] =
{
"aB:C:d:D:efFHi:IJ:K:l:mMn:N:p:P:QqrRS:st:Tvw:x",
"device [device] [...]",
"Qualcomm Atheros INT6x00 Powerline Device Manager",
"a\tread device attributes using VS_OP_ATTRIBUTES",
"B n\tperform pushbutton action (n) using MS_PB_ENC [1|2|3|'join'|'leave'|'status']",
"C n\tflash NVRAM with module (n) using VS_MOD_NVM [1|2|3|'nvm'|'pib'|'both']",
"d f\tdump and clear watchdog report to file (f) using VS_WD_RPT",
"D x\tset DAK to (x) for option -J [" DAK1 "]",
"e\tredirect stderr to stdout",
"f\tread NVRAM Configuration using VS_GET_NVM",
"F[F]\tflash [force] NVRAM with PIB and firmware using VS_MOD_NVM",
"H\tstop host action requests using VS_HOST_ACTION.IND",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"I\tread device identity using VS_RD_MOD",
"J x\tset NMK on remote device (x) via local device using VS_SET_KEY (see -K)",
"K x\tset NMK to (x) for options -J and -M [" NMK1 "]",
"l n\tloop (n) times [" LITERAL (INT6K_LOOP) "]",
"m\tread network membership information using VS_NW_INFO",
"M\tset NMK on local device using VS_SET_KEY (see -K)",
"n f\tread NVM from SDRAM to file (f) using VS_RD_MOD",
"N f\twrite NVM file (f) to SDRAM using VS_WR_MOD",
"p f\tread PIB from SDRAM to file (f) using VS_RD_MOD",
"P f\twrite PIB file (f) to SDRAM using VS_WR_MOD",
"q\tquiet mode",
"Q\tquick flash (return immediately)",
"r\tread hardware and firmware revision using VS_SW_VER",
"R\treset device using VS_RS_DEV",
"s\tread SDRAM Configuration using VS_RD_CBLOCK",
"S f\twrite an SDRAM Configuration file (f) using VS_SET_SDRAM",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"T\trestore factory defaults using VS_FAC_DEFAULTS",
"v\tverbose mode",
"w n\tpause (n) seconds [" LITERAL (INT6K_WAIT) "]",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
signed loop = INT6K_LOOP;
signed wait = INT6K_WAIT;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'a':
_setbits (plc.flags, PLC_ATTRIBUTES);
break;
case 'B':
_setbits (plc.flags, PLC_PUSH_BUTTON);
plc.pushbutton = (unsigned)(uintspec (synonym (optarg, buttons, SIZEOF (buttons)), 0, UCHAR_MAX));
break;
case 'C':
_setbits (plc.flags, PLC_FLASH_DEVICE);
plc.module = (unsigned)(uintspec (synonym (optarg, modules, SIZEOF (modules)), 0, UCHAR_MAX));
break;
case 'd':
_setbits (plc.flags, PLC_WATCHDOG_REPORT);
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.rpt.file = open (plc.rpt.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.rpt.name);
}
#ifndef WIN32
chown (optarg, getuid (), getgid ());
#endif
plc.readaction = 3;
break;
case 'D':
if (!strcmp (optarg, "none"))
{
memcpy (plc.DAK, keys [0].DAK, sizeof (plc.DAK));
break;
}
if (!strcmp (optarg, "key1"))
{
memcpy (plc.DAK, keys [1].DAK, sizeof (plc.DAK));
break;
}
if (!strcmp (optarg, "key2"))
{
memcpy (plc.DAK, keys [2].DAK, sizeof (plc.DAK));
break;
}
if (!hexencode (plc.DAK, sizeof (plc.DAK), (char const *)(optarg)))
{
error (1, errno, PLC_BAD_DAK, optarg);
}
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'f':
_setbits (plc.flags, PLC_NVRAM_INFO);
break;
case 'F':
_setbits (plc.module, (VS_MODULE_MAC | VS_MODULE_PIB));
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
_setbits (plc.module, VS_MODULE_FORCE);
}
_setbits (plc.flags, PLC_FLASH_DEVICE);
break;
case 'H':
_setbits (plc.flags, PLC_HOST_ACTION);
break;
case 'I':
_setbits (plc.flags, PLC_READ_IDENTITY);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'J':
if (!hexencode (plc.RDA, sizeof (plc.RDA), (char const *)(optarg)))
{
error (1, errno, PLC_BAD_MAC, optarg);
}
_setbits (plc.flags, PLC_SETREMOTEKEY);
break;
case 'K':
if (!strcmp (optarg, "none"))
{
memcpy (plc.NMK, keys [0].NMK, sizeof (plc.NMK));
break;
}
if (!strcmp (optarg, "key1"))
{
memcpy (plc.NMK, keys [1].NMK, sizeof (plc.NMK));
break;
}
if (!strcmp (optarg, "key2"))
{
memcpy (plc.NMK, keys [2].NMK, sizeof (plc.NMK));
break;
}
if (!hexencode (plc.NMK, sizeof (plc.NMK), (char const *)(optarg)))
{
error (1, errno, PLC_BAD_NMK, optarg);
}
break;
case 'M':
_setbits (plc.flags, PLC_SETLOCALKEY);
break;
case 'l':
loop = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'm':
_setbits (plc.flags, PLC_NETWORK);
break;
case 'N':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.NVM.file = open (plc.NVM.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.NVM.name);
}
if (nvmfile1 (&plc.NVM))
{
error (1, errno, "Bad firmware file: %s", plc.NVM.name);
}
_setbits (plc.flags, PLC_WRITE_MAC);
break;
case 'n':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.nvm.file = open (plc.nvm.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.nvm.name);
}
#ifndef WIN32
chown (optarg, getuid (), getgid ());
#endif
_setbits (plc.flags, PLC_READ_MAC);
break;
case 'P':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.PIB.file = open (plc.PIB.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.PIB.name);
}
if (pibfile1 (&plc.PIB))
{
error (1, errno, "Bad parameter file: %s", plc.PIB.name);
}
_setbits (plc.flags, PLC_WRITE_PIB);
break;
case 'p':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.pib.file = open (plc.pib.name = optarg, O_BINARY|O_CREAT|O_RDWR|O_TRUNC, FILE_FILEMODE)) == -1)
{
error (1, errno, "%s", plc.pib.name);
}
#ifndef WIN32
chown (optarg, getuid (), getgid ());
#endif
_setbits (plc.flags, PLC_READ_PIB);
break;
case 'Q':
_setbits (plc.flags, PLC_QUICK_FLASH);
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'R':
_setbits (plc.flags, PLC_RESET_DEVICE);
break;
case 'r':
_setbits (plc.flags, PLC_VERSION);
break;
case 'S':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.CFG.file = open (plc.CFG.name = optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc.CFG.name);
}
if (sdramfile (plc.CFG.file, optarg, plc.flags))
{
error (1, ECANCELED, "SDRAM config file %s is corrupt", optarg);
}
_setbits (plc.flags, PLC_SDRAM_CONFIG);
break;
case 's':
_setbits (plc.flags, PLC_SDRAM_INFO);
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'T':
_setbits (plc.flags, PLC_FACTORY_DEFAULTS);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'V':
_setbits (plc.flags, PLC_SNIFFER);
plc.action = (uint8_t)(uintspec (optarg, 0, UCHAR_MAX));
break;
case 'w':
wait = (unsigned)(uintspec (optarg, 0, 3600));
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
{
if (plc.nvm.file != -1)
{
error (1, ECANCELED, PLC_NODEVICE);
}
if (plc.pib.file != -1)
{
error (1, ECANCELED, PLC_NODEVICE);
}
if (plc.rpt.file != -1)
{
error (1, ECANCELED, PLC_NODEVICE);
}
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
manager (&plc, loop, wait);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
manager (&plc, loop, wait);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"cd:ei:l:o:nqrRtTuvw:x",
"device [device] [...]",
"Qualcomm Atheros INT6x00 PHY Rate Monitor",
"c\tdisplay coded PHY rates",
"d n\ttraffic duration is (n) seconds per leg [" LITERAL (PLC_ECHOTIME) "]",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"l n\tloop (n) times [" LITERAL (INT6KRATE_LOOP) "]",
"n\tnetwork TX/RX information",
"o n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_TIMEOUT) "]",
"q\tquiet mode",
"r\trequest device information",
"R\treset device with VS_RS_DEV",
"t\tgenerate network traffic (one-to-many)",
"T\tgenerate network traffic (many-to-many)",
"u\tdisplay uncoded PHY rates",
"v\tverbose mode",
"w n\twait (n) seconds [" LITERAL (INT6KRATE_WAIT) "]",
"x\texit on error",
(char const *) (0)
};
#include "../plc/plc.c"
signed loop = INT6KRATE_LOOP;
signed wait = INT6KRATE_WAIT;
signed c;
optind = 1;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
plc.timer = PLC_ECHOTIME;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'c':
_clrbits (plc.flags, PLC_UNCODED_RATES);
break;
case 'd':
plc.timer = (unsigned)(uintspec (optarg, 1, 60));
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'l':
loop = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'n':
_setbits (plc.flags, PLC_NETWORK);
break;
case 'o':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'q':
_setbits (plc.flags, PLC_SILENCE);
break;
case 'r':
_setbits (plc.flags, PLC_VERSION);
break;
case 'R':
_setbits (plc.flags, PLC_RESET_DEVICE);
break;
case 't':
_setbits (plc.flags, PLC_LOCAL_TRAFFIC);
break;
case 'T':
_setbits (plc.flags, PLC_NETWORK_TRAFFIC);
break;
case 'u':
_setbits (plc.flags, PLC_UNCODED_RATES);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'w':
wait = (unsigned)(uintspec (optarg, 0, 3600));
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
desuid ();
if (_allclr (plc.flags, (PLC_VERSION | PLC_LOCAL_TRAFFIC | PLC_NETWORK_TRAFFIC | PLC_RESET_DEVICE)))
{
_setbits (plc.flags, PLC_NETWORK);
}
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
manager (&plc, loop, wait);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
manager (&plc, loop, wait);
argv++;
argc--;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
struct message message;
static char const * optv [] =
{
"e:i:qt:v",
PUTOPTV_S_DIVINE,
"Qualcomm Atheros Ethernet Frame Read Utility",
"e x\tethertype is (x) [" LITERAL (EFRU_ETHERTYPE) "]",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (s) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (n) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tsuppress normal output",
"t n\tread timeout is (n) milliseconds [" LITERAL (CHANNEL_FOREVER) "]",
"v\tverbose messages on stdout",
(char const *) (0)
};
flag_t flags = (flag_t)(0);
signed length;
signed c;
if (getenv (EFRU_INTERFACE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (EFRU_INTERFACE));
#else
channel.ifname = strdup (getenv (EFRU_INTERFACE));
#endif
}
optind = 1;
channel.type = EFRU_ETHERTYPE;
channel.timeout = CHANNEL_FOREVER;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
channel.type = (uint16_t)(basespec (optarg, 16, sizeof (channel.type)));
break;
case 'i':
#if defined (WIN32)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (flags, EFRU_SILENCE);
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (flags, EFRU_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ECANCELED, ERROR_TOOMANY);
}
openchannel (&channel);
while ((length = readpacket (&channel, &message, sizeof (message))) >= 0)
{
hexdump (&message, 0, length, stdout);
}
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"d:ei:p:qr:v",
"[device] [...]",
"Qualcomm Atheros 16-bit MDIO Register Editor",
"d n\tdata value is (n) [0x0000]",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"p n\tPHY number (n) [0xFF]",
"q\tquiet mode",
"r n\tregister number (n) [0xFF]",
"v\tverbose mode",
(char const *) (0)
};
uint8_t mode = 0;
uint8_t phy = 0;
uint8_t reg = 0;
uint16_t data = 0;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'd':
mode = 1;
data = (uint16_t)(uintspec (optarg, 0, 0xFFFF));
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'p':
phy = (uint8_t)(uintspec (optarg, 0, 0x1F));
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 'r':
reg = (uint8_t)(uintspec (optarg, 0, 0x1F));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
desuid ();
if (!argc)
{
function (&channel, mode, phy, reg, data);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
function (&channel, mode, phy, reg, data);
argv++;
argc--;
}
closechannel (&channel);
return (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
char firmware [PLC_VERSION_STRING];
static char const * optv [] =
{
"ei:lqt:vw:xX",
"file [file] [...]",
"Qualcomm Atheros PLC Test Applet Loader",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" OPTSTR (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" OPTSTR (CHANNEL_ETHDEVICE) "]",
#endif
"l\tloop until program is terminated",
"q\tquiet mode",
"t n\tread timeout is (n) milliseconds [" OPTSTR (CHANNEL_TIMEOUT) "]",
"v\tverbose mode",
"w n\twait time is (n) seconds [" OPTSTR (PLC_TIMER) "]",
"x\texit on error",
"X\texit on start",
(char const *) (0)
};
#include "../plc/plc.c"
signed loop = 0;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'l':
loop = 1;
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 't':
channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'w':
plc.timer = (unsigned)(uintspec (optarg, 0, 3600));
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
case 'X':
_setbits (plc.flags, PLC_QUICK_FLASH);
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (WaitForStart (&plc, firmware, sizeof (firmware)))
{
error (1, ECANCELED, PLC_NODETECT);
}
if (strcmp (firmware, "BootLoader"))
{
error (1, ECANCELED, "BootLoader must be running");
}
do
{
sequence (&plc, argc, argv);
}
while (loop);
free (plc.message);
closechannel (&channel);
return (plc.state);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ei:qv",
"action priority destination rate ttl operand condition [...] [device] [...]\n\n where condition is field operator value",
"CoQos Stream Utility",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"v\tverbose mode",
(char const *) (0)
};
#include "../plc/plc.c"
struct connection connection;
struct MMEClassifier * rule = (struct MMEClassifier *)(&connection.rule.CLASSIFIERS);
uint16_t * word;
uint8_t * byte;
signed code;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
memset (&connection, 0, sizeof (connection));
if ((code = lookup (* argv++, actions, SIZEOF (actions))) == -1)
{
assist (*--argv, CLASSIFIER_ACTION_NAME, actions, SIZEOF (actions));
}
connection.cspec.CONN_CAP = (uint8_t)(code);
argc--;
if (!argc)
{
error (1, ECANCELED, "Expected Priority: 0-15");
}
connection.cspec.CONN_COQOS_PRIO = (uint8_t)(uintspec (* argv++, 0, 15));
argc--;
if (!argc)
{
error (1, ECANCELED, "Expected Destination MAC Address");
}
if (!hexencode (connection.APP_DA, sizeof (connection.APP_DA), synonym (* argv++, devices, SIZEOF (devices))))
{
error (1, errno, "Invalid MAC=[%s]", *--argv);
}
argc--;
if (!argc)
{
error (1, ECANCELED, "Expected Data Rate: 10-9000 (kbps)");
}
connection.cspec.CONN_RATE = (uint16_t)(uintspec (* argv++, 1, 9000));
argc--;
if (!argc)
{
error (1, ECANCELED, "Expected TTL: 10000-2000000 (microseconds)");
}
connection.cspec.CONN_TTL = (uint32_t)(uintspec (* argv++, 10000, 2000000));
argc--;
if ((code = lookup (* argv++, operands, SIZEOF (operands))) == -1)
{
assist (*--argv, CLASSIFIER_OPERAND_NAME, operands, SIZEOF (operands));
}
connection.rule.MOPERAND = (uint8_t)(code);
argc--;
while ((* argv) && (lookup (* argv, controls, SIZEOF (controls)) == -1))
{
if ((code = lookup (* argv++, fields, SIZEOF (fields))) == -1)
{
assist (*--argv, CLASSIFIER_FIELD_NAME, fields, SIZEOF (fields));
}
rule->CR_PID = (uint8_t)(code);
argc--;
if ((code = lookup (* argv++, operators, SIZEOF (operators))) == -1)
{
assist (*--argv, CLASSIFIER_OPERATOR_NAME, operators, SIZEOF (operators));
}
rule->CR_OPERAND = (uint8_t)(code);
argc--;
if (!argc || !* argv)
{
error (1, ENOTSUP, "Have %s '%s' without any value", CLASSIFIER_OPERATOR_NAME, *--argv);
}
switch (rule->CR_PID)
{
case FIELD_ETH_SA:
case FIELD_ETH_DA:
bytespec (* argv++, rule->CR_VALUE, ETHER_ADDR_LEN);
break;
case FIELD_IPV4_SA:
case FIELD_IPV4_DA:
ipv4spec (* argv++, rule->CR_VALUE);
break;
case FIELD_IPV6_SA:
case FIELD_IPV6_DA:
ipv6spec (* argv++, rule->CR_VALUE);
break;
case FIELD_VLAN_UP:
case FIELD_IPV4_TOS:
case FIELD_IPV4_PROT:
byte = (uint8_t *)(rule->CR_VALUE);
*byte = (uint8_t)(basespec (* argv++, 0, sizeof (* byte)));
break;
case FIELD_VLAN_ID:
case FIELD_TCP_SP:
case FIELD_TCP_DP:
case FIELD_UDP_SP:
case FIELD_UDP_DP:
case FIELD_IP_SP:
case FIELD_IP_DP:
word = (uint16_t *)(rule->CR_VALUE);
*word = (uint16_t)(basespec (* argv++, 0, sizeof (* word)));
*word = htons (*word);
break;
case FIELD_ETH_TYPE:
word = (uint16_t *)(rule->CR_VALUE);
*word = (uint16_t)(basespec (* argv++, 0, sizeof (* word)));
*word = htons (*word);
break;
case FIELD_HPAV_MME:
bytespec (* argv++, rule->CR_VALUE, sizeof (uint8_t) + sizeof (uint16_t));
byte = (uint8_t *)(rule->CR_VALUE);
HTOBE16 ((uint16_t)(* ++byte));
break;
case FIELD_IPV6_TC:
case FIELD_IPV6_FL:
case FIELD_TCP_ACK:
default:
error (1, ENOTSUP, "Field '%s' (0x%02X)", argv [-2], rule->CR_PID);
break;
}
connection.rule.NUM_CLASSIFIERS++;
if (connection.rule.NUM_CLASSIFIERS > RULE_MAX_CLASSIFIERS)
{
error (1, ENOTSUP, "More than %d classifiers in rule", RULE_MAX_CLASSIFIERS);
}
rule++;
argc--;
}
connection.cspec.CSPEC_VERSION = 0x0001;
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
add_conn (&plc, &connection);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
add_conn (&plc, &connection);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"ei:qv",
"[sta|cid|rsvd|vic|bw|bwc] [limit] [device] [...]",
"CoQos Stream Utility",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"q\tquiet mode",
"v\tverbose mode",
(char const *) (0)
};
#include "../plc/plc.c"
uint16_t cid = 0;
uint16_t limit = 0;
uint8_t type;
signed code;
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (plc.flags, PLC_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if ((code = lookup (* argv++, types, SIZEOF (types))) == -1)
{
assist (*--argv, CONTROL, types, SIZEOF (types));
}
type = (uint8_t)(code);
argc--;
if (type == CONTROL_CID)
{
if (!argc)
{
error (1, errno, "Expected Connection Identifier");
}
if (!hexencode ((uint8_t *)(&cid), sizeof (cid), * argv++))
{
error (1, errno, "Invalid CID");
}
cid = htons (cid);
argc--;
}
else if (type == CONTROL_BW)
{
if (!argc)
{
error (1, errno, "Expected Bandwidth Limit");
}
limit = atoi (* argv++);
argc--;
}
openchannel (&channel);
if (!(plc.message = malloc (sizeof (* plc.message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (!argc)
{
con_info (&plc, type, cid, limit);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
con_info (&plc, type, cid, limit);
argc--;
argv++;
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"a:d:ef:i:n:p:qrs:tvw",
"device [device] [...] [> stdout]",
"Qualcomm Atheros Ethernet PHY Settings",
"a s\tadvertise capabilities as (s) ['1000Full'|'100Full'|'100Half'|10Full'|'10Half']",
"d s\tduplex setting is (s) ['half'|'full']",
"e\tredirect stderr to stdout",
"f s\tflow control is (s) ['on'|'tx'|'rx'|'off']",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"n s\tauto-negotiate mode is (s) ['on'|'off']",
"p n\tport number is (n) [" LITERAL (ETH_PORT) "]",
"q\tquiet mode",
"r\tread settings instead of write settings",
"s s\ttransmission speed in mbps is (s) ['10'|'100'|'1000']",
"v\tverbose mode",
"w\twrite settings instead of read settings",
(char const *) (0)
};
struct phy_settings settings =
{
0,
1,
0,
0,
0,
0
};
flag_t flags = (flag_t)(0);
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'a':
if ((c = lookup (optarg, advcap, ADVCAP)) == -1)
{
assist (optarg, "capability", advcap, ADVCAP);
}
settings.ADVCAPS |= (uint8_t)(c);
break;
case 'd':
if ((c = lookup (optarg, duplex, DUPLEX)) == -1)
{
assist (optarg, "duplex", duplex, DUPLEX);
}
settings.EDUPLEX = (uint8_t)(c);
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'f':
if ((c = lookup (optarg, control, CONTROL)) == -1)
{
assist (optarg, "control", control, CONTROL);
}
settings.EFLOWCONTROL = (uint8_t)(c);
break;
case 'n':
if ((c = lookup (optarg, negotiate, NEGOTIATE)) == -1)
{
assist (optarg, "auto-negotiate", negotiate, NEGOTIATE);
}
settings.AUTONEGOTIATE = (uint8_t)(c);
break;
case 's':
if ((c = lookup (optarg, speeds, SPEEDS)) == -1)
{
assist (optarg, "speed", speeds, SPEEDS);
}
settings.ESPEED = (uint8_t)(c);
break;
case 't':
_setbits (flags, PLC_ANALYSE);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'p':
settings.MCONTROL &= 0x0F;
settings.MCONTROL |= (unsigned)(uintspec (optarg, 0, 7)) << 4;
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 'r':
settings.MCONTROL &= 0xF0;
settings.MCONTROL |= 0x00;
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
case 'w':
settings.MCONTROL &= 0xF0;
settings.MCONTROL |= 0x01;
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
if (!argc)
{
PHYSettings (&channel, &settings, flags);
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
PHYSettings (&channel, &settings, flags);
argc--;
argv++;
}
closechannel (&channel);
exit (0);
}
int main (int argc, const char * argv [])
{
extern struct channel channel;
static const char *optv [] =
{
"C:i:eFN:p:P:qt:vx",
"-C file -P file -N file",
"Atheros Powerline Device Flash Utility for INT6300",
"C f\twrite CFG file to device using VS_SET_SDRAM",
"e\tredirect stderr messages to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface number [2]",
#else
"i s\thost interface name [" CHANNEL_ETHDEVICE "]",
#endif
"F[F]\tflash [force] NVRAM after firmware start using VS_MOD_NVM",
"N f\twrite NVM file to device using VS_WR_MEM",
"P f\twrite PIB file to device using VS_WR_MEM",
"q\tquiet mode",
#if defined (WINPCAP) || defined (LIBPCAP)
"t n\tread capture time is (n) milliseconds [50]",
#else
"t n\tread timeout is (n) milliseconds [50]",
#endif
"v\tverbose mode",
"x\texit on error",
(const char *) (0)
};
#include "../plc/plc.c"
char firmware [PLC_VERSION_STRING];
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
opterr = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
break;
case 't':
channel.timeout = (unsigned)(uintspec (optarg, 0, UINT_MAX));
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
break;
}
}
openchannel (&channel);
desuid ();
optind = 1;
opterr = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'C':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.CFG.file = open (optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", optarg);
}
if (sdramfile (plc.CFG.file, optarg, plc.flags))
{
error (1, ECANCELED, "CFG file %s is corrupt", optarg);
}
_setbits (plc.flags, PLC_SDRAM_CONFIG);
plc.CFG.name = optarg;
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'F':
_setbits (plc.module, PLC_MODULE_NVM_PIB);
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
_setbits (plc.module, VS_MODULE_FORCE);
}
_setbits (plc.flags, PLC_FLASH_DEVICE);
break;
case 'N':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.NVM.file = open (optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", optarg);
}
plc.NVM.name = optarg;
if (nvmfile1 (&plc.NVM))
{
error (1, errno, "Bad firmware file: %s", plc.NVM.name);
}
_setbits (plc.flags, PLC_WRITE_MAC);
break;
case 'P':
if (!checkfilename (optarg))
{
error (1, EINVAL, "%s", optarg);
}
if ((plc.PIB.file = open (optarg, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", optarg);
}
plc.PIB.name = optarg;
if (pibfile1 (&plc.PIB))
{
error (1, errno, "Bad parameter file: %s", plc.PIB.name);
}
_setbits (plc.flags, PLC_WRITE_PIB);
break;
case 'q':
_setbits (plc.flags, PLC_SILENCE);
break;
case 'v':
_setbits (plc.flags, PLC_VERBOSE);
break;
case 'x':
_setbits (plc.flags, PLC_BAILOUT);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (argc)
{
error (1, ECANCELED, "Too many arguments");
}
if (plc.CFG.file == -1)
{
error (1, ECANCELED, "No CFG file specified");
}
if (plc.PIB.file == -1)
{
error (1, ECANCELED, "No PIB file specified");
}
if (plc.NVM.file == -1)
{
error (1, ECANCELED, "No NVM file specified");
}
if (!(plc.message = malloc (sizeof (struct message))))
{
error (1, errno, PLC_NOMEMORY);
}
if (WaitForStart (&plc, firmware, sizeof (firmware)))
{
Failure (&plc, "Device must be connected");
return (-1);
}
if (plc.hardwareID > CHIPSET_INT6300)
{
Failure (&plc, "Device must be %s or earlier; try using int6kboot.", chipsetname (CHIPSET_INT6300));
return (-1);
}
if (strcmp (firmware, "BootLoader"))
{
Failure (&plc, "Bootloader must be running");
return (-1);
}
if (!StartDevice1 (&plc))
{
if (_anyset (plc.flags, PLC_FLASH_DEVICE))
{
UpgradeDevice1 (&plc);
}
}
free (plc.message);
closechannel (&channel);
exit (0);
}
int main (int argc, char const * argv [])
{
extern struct channel channel;
static char const * optv [] =
{
"Ac:Dei:MnNqSUv",
"device",
"Qualcomm Atheros Powerline Device Identity",
"A\tEthernet address (MAC)",
"c c\tcharacter delimiter is (c)",
"D\tDevice Access Key (DAK)",
"e\tredirect stderr to stdout",
#if defined (WINPCAP) || defined (LIBPCAP)
"i n\thost interface is (n) [" LITERAL (CHANNEL_ETHNUMBER) "]",
#else
"i s\thost interface is (s) [" LITERAL (CHANNEL_ETHDEVICE) "]",
#endif
"M\tNetwork Membership Key (NMK)",
"n\tappend newline on output",
"N\tnetwork HFID",
"q\tquiet mode",
"S\tmanufacturer HFID",
"U\tuser HFID",
"v\tverbose mode",
(char const *) (0)
};
signed newline = '\n';
signed key = INT6KID_DAK;
flag_t flags = (flag_t)(0);
signed c;
if (getenv (PLCDEVICE))
{
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (getenv (PLCDEVICE));
#else
channel.ifname = strdup (getenv (PLCDEVICE));
#endif
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch (c)
{
case 'A':
key = INT6KID_MAC;
break;
case 'c':
newline = * optarg;
break;
case 'D':
key = INT6KID_DAK;
break;
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'i':
#if defined (WINPCAP) || defined (LIBPCAP)
channel.ifindex = atoi (optarg);
#else
channel.ifname = optarg;
#endif
break;
case 'M':
key = INT6KID_NMK;
break;
case 'n':
_setbits (flags, PLC_NEWLINE);
break;
case 'N':
key = INT6KID_NET;
break;
case 'q':
_setbits (channel.flags, CHANNEL_SILENCE);
_setbits (flags, PLC_SILENCE);
break;
case 'S':
key = INT6KID_MFG;
break;
case 'U':
key = INT6KID_USR;
break;
case 'v':
_setbits (channel.flags, CHANNEL_VERBOSE);
_setbits (flags, PLC_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
openchannel (&channel);
if (!argc)
{
ReadKey1 (&channel, newline, key);
if (_anyset (flags, PLC_NEWLINE))
{
putc (newline, stdout);
}
}
while ((argc) && (* argv))
{
if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
{
error (1, errno, PLC_BAD_MAC, * argv);
}
ReadKey1 (&channel, newline, key);
if (_anyset (flags, PLC_NEWLINE))
{
putc (newline, stdout);
}
argv++;
argc--;
}
closechannel (&channel);
return (0);
}