static signed pibchain2 (void const * memory, char const * filename, flag_t flags)
{
struct nvm_header2 * nvm_header;
size_t origin = ~0;
size_t offset = 0;
signed module = 0;
do
{
nvm_header = (struct nvm_header2 *)((char *)(memory) + offset);
if (LE16TOH (nvm_header->MajorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE16TOH (nvm_header->MinorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE32TOH (nvm_header->PrevHeader) != origin)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
return (-1);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
error (0, 0, NVM_HDR_CHECKSUM, filename, module);
return (-1);
}
origin = offset;
offset += sizeof (* nvm_header);
if (LE32TOH (nvm_header->ImageType) == NVM_IMAGE_PIB)
{
pibpeek2 ((char *)(memory) + offset);
break;
}
if (checksum32 ((char *)(memory) + offset, LE32TOH (nvm_header->ImageLength), nvm_header->ImageChecksum))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_IMG_CHECKSUM, filename, module);
}
return (-1);
}
offset += LE32TOH (nvm_header->ImageLength);
module++;
}
while (~nvm_header->NextHeader);
return (0);
}
static signed chknvm (char const * filename, flag_t flags)
{
void * memory = (void *)(0);
signed extent = 0;
signed status = 0;
signed fd;
if ((fd = open (filename, O_BINARY|O_RDONLY)) == -1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, FILE_CANTOPEN, filename);
}
return (-1);
}
if ((extent = lseek (fd, 0, SEEK_END)) == -1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, FILE_CANTSIZE, filename);
}
return (-1);
}
if (!(memory = malloc (extent)))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, FILE_CANTLOAD, filename);
}
return (-1);
}
if (lseek (fd, 0, SEEK_SET))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, FILE_CANTLOAD, filename);
}
return (-1);
}
if (read (fd, memory, extent) != extent)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, FILE_CANTREAD, filename);
}
return (-1);
}
close (fd);
if (LE32TOH (* (uint32_t *)(memory)) == 0x60000000)
{
status = nvmimage2 (memory, extent, filename, flags);
}
else
{
status = nvmchain2 (memory, extent, filename, flags);
}
free (memory);
return (status);
}
static signed nvmimage2 (void const * memory, size_t extent, char const * filename, flag_t flags)
{
struct nvm_header1 * nvm_header;
unsigned module = 0;
uint32_t offset = 0;
do
{
nvm_header = (struct nvm_header1 *)((char *)(memory) + offset);
if (LE32TOH (nvm_header->HEADERVERSION) != 0x60000000)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_CHECKSUM, filename, module);
}
return (-1);
}
offset += sizeof (* nvm_header);
extent -= sizeof (* nvm_header);
if (_anyset (flags, NVM_VERBOSE))
{
printf ("------- %s (%d) -------\n", filename, module);
nvmpeek1 (nvm_header);
}
if (LE32TOH (nvm_header->IMAGETYPE) == NVM_IMAGE_FIRMWARE)
{
firmware (filename, module, (char *)(memory) + offset, 0x70, flags);
}
if (checksum32 ((char *)(memory) + offset, LE32TOH (nvm_header->IMAGELENGTH), nvm_header->IMAGECHECKSUM))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_IMG_CHECKSUM, filename, module);
}
return (-1);
}
offset += LE32TOH (nvm_header->IMAGELENGTH);
extent -= LE32TOH (nvm_header->IMAGELENGTH);
module++;
}
while (nvm_header->NEXTHEADER);
if (extent)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
}
return ((signed)(extent));
}
signed slac_debug (struct session * session, signed status, char const * string, char const * format, ...)
{
extern char const * program_name;
if (_allclr (session->flags, SLAC_SILENCE))
{
if ((program_name) && (* program_name))
{
fprintf (stderr, "%s: ", program_name);
}
if ((string) && (* string))
{
fprintf (stderr, "%s: ", string);
}
if ((format) && (*format))
{
va_list arglist;
va_start (arglist, format);
vfprintf (stderr, format, arglist);
va_end (arglist);
}
fprintf (stderr, "\n");
fflush (stderr);
}
if (status)
{
exit (status);
}
return (-1);
}
int main (int argc, char const * argv [])
{
static char const * optv [] =
{
"imqrv",
"file [file] [...]",
"Qualcomm Atheros PLC Image File Validator",
"i\tprint firmware identity string",
"m\tdisplay manifest",
"q\tsuppress messages",
"r\tprint firmware revision string",
"v\tverbose messages",
(char const *) (0)
};
flag_t flags = (flag_t)(0);
signed state = 0;
signed c;
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'i':
_setbits (flags, NVM_IDENTITY);
break;
case 'm':
_setbits (flags, NVM_MANIFEST);
break;
case 'r':
_setbits (flags, NVM_FIRMWARE);
break;
case 'q':
_setbits (flags, NVM_SILENCE);
break;
case 'v':
_setbits (flags, NVM_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
while ((argc) && (* argv))
{
if (chknvm (* argv, flags))
{
state = 1;
}
else if (_allclr (flags, (NVM_VERBOSE|NVM_SILENCE|NVM_MANIFEST|NVM_FIRMWARE|NVM_IDENTITY)))
{
printf ("%s looks good\n", * argv);
}
argc--;
argv++;
}
return (state);
}
signed BootParameters2 (struct plc * plc)
{
unsigned module = 0;
struct nvm_header2 nvm_header;
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
do
{
if (read (plc->PIB.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, NVM_HDR_CANTREAD, plc->PIB.name, module);
}
if (LE16TOH (nvm_header.MajorVersion) != 1)
{
error (1, ECANCELED, NVM_HDR_VERSION, plc->PIB.name, module);
}
if (LE16TOH (nvm_header.MinorVersion) != 1)
{
error (1, ECANCELED, NVM_HDR_VERSION, plc->PIB.name, module);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
error (1, ECANCELED, NVM_HDR_CHECKSUM, plc->PIB.name, module);
}
#if 0
if (_allclr (LE16TOH (nvm_header.ExecuteMask), (1 << (plc->hardwareID - 1))))
{
if (lseek (plc->PIB.file, LE32TOH (nvm_header.NextHeader), SEEK_SET) == -1)
{
error (1, errno, "Can't skip module: %s (%d)", plc->PIB.name, module);
}
}
else
#endif
if (LE32TOH (nvm_header.ImageType) == NVM_IMAGE_PIB)
{
if (WriteExecuteParameters2 (plc, module, &nvm_header))
{
return (-1);
}
break;
}
if (lseek (plc->PIB.file, LE32TOH (nvm_header.NextHeader), SEEK_SET) == -1)
{
error (1, errno, "Can't skip module: %s (%d)", plc->PIB.name, module);
}
module++;
}
while (~nvm_header.NextHeader);
return (0);
}
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 void assemble (flag_t flags)
{
extern signed c;
c = mygetc ();
while (c != EOF)
{
if (isspace (c))
{
do
{
c = mygetc ();
}
while (isspace (c));
continue;
}
if ((c == '#') || (c == ';'))
{
do
{
c = mygetc ();
}
while (nobreak (c));
continue;
}
phy = integer (16);
reg = integer (16);
data = integer (16);
mask = integer (16);
instr = MDIO16_INSTR (1, 1, phy, reg, 2);
write (STDOUT_FILENO, &instr, sizeof (instr));
data = HTOLE16 (data & 0xFFFF);
write (STDOUT_FILENO, &data, sizeof (data));
mask = HTOLE16 (mask & 0xFFFF);
write (STDOUT_FILENO, &mask, sizeof (mask));
count++;
if (_anyset (flags, MDIO_VERBOSE))
{
fprintf (stderr, "INSTR=0x%04X DATA=0x%04X MASK=0x%04X\n", instr, data, mask);
}
if ((c == ';') || (c == EOF))
{
c = mygetc ();
continue;
}
if (_allclr (flags, MDIO_SILENCE))
{
error (1, 0, "Illegal character or missing terminator: line %d col %d", row, col);
}
}
return;
}
signed WaitForRestart (struct plc * plc)
{
if (_allclr (plc->flags, PLC_QUICK_FLASH))
{
char firmware [PLC_VERSION_STRING];
if (WaitForReset (plc, firmware, sizeof (firmware)))
{
error (PLC_EXIT (plc), 0, "Device did not Reset");
return (-1);
}
if (WaitForStart (plc, firmware, sizeof (firmware)))
{
error (PLC_EXIT (plc), 0, "Device did not Start");
return (-1);
}
}
return (0);
}
void Request (struct plc * plc, char const *format, ...)
{
if (_allclr (plc->flags, PLC_SILENCE))
{
char address [ETHER_ADDR_LEN * 3];
struct channel * channel = (struct channel *)(plc->channel);
hexdecode (channel->peer, sizeof (channel->peer), address, sizeof (address));
fprintf (stderr, "%s %s ", channel->ifname, address);
if ((format) && (*format))
{
va_list arglist;
va_start (arglist, format);
vfprintf (stderr, format, arglist);
va_end (arglist);
}
fprintf (stderr, "\n");
}
return;
}
void Confirm (struct int6k * int6k, const char *format, ...)
{
struct channel * channel = (struct channel *)(int6k->channel);
struct message * message = (struct message *)(int6k->message);
if (_allclr (int6k->flags, INT6K_SILENCE))
{
char address [ETHER_ADDR_LEN * 3];
hexdecode (message->ethernet.OSA, sizeof (message->ethernet.OSA), address, sizeof (address));
fprintf (stderr, "%s %s ", channel->name, address);
if ((format) && (*format))
{
va_list arglist;
va_start (arglist, format);
vfprintf (stderr, format, arglist);
va_end (arglist);
}
fprintf (stderr, "\n");
}
return;
}
static void function (struct channel * channel, flag_t flags)
{
struct message message;
signed length;
while ((length = readpacket (channel, &message, sizeof (message))) >= 0)
{
if (!length)
{
continue;
}
if (_allclr (flags, HPAV_SILENCE))
{
MMEPeek (&message, length, stdout);
}
if (_anyset (flags, HPAV_VERBOSE))
{
hexdump (&message, 0, length, stdout);
}
}
return;
}
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);
}
static signed nvmchain2 (void const * memory, size_t extent, char const * filename, flag_t flags)
{
struct nvm_header2 * nvm_header;
unsigned module = 0;
uint32_t origin = ~0;
uint32_t offset = 0;
uint32_t length = 0;
do
{
nvm_header = (struct nvm_header2 *)((char *)(memory) + offset);
if (LE16TOH (nvm_header->MajorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE16TOH (nvm_header->MinorVersion) != 1)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_VERSION, filename, module);
}
return (-1);
}
if (LE32TOH (nvm_header->PrevHeader) != origin)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
return (-1);
}
if (checksum32 (nvm_header, sizeof (* nvm_header), 0))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, 0, NVM_HDR_CHECKSUM, filename, module);
}
return (-1);
}
origin = offset;
offset += sizeof (* nvm_header);
extent -= sizeof (* nvm_header);
length = LE32TOH (nvm_header->ImageLength);
if (_anyset (flags, NVM_VERBOSE))
{
printf ("------- %s (%d) -------\n", filename, module);
nvmpeek2 (nvm_header);
}
if (LE32TOH (nvm_header->ImageType) == NVM_IMAGE_MANIFEST)
{
if (_anyset (flags, NVM_MANIFEST))
{
printf ("------- %s (%d) -------\n", filename, module);
manifest ((char *)(memory) + offset, length);
return (0);
}
}
if (checksum32 ((char *)(memory) + offset, length, nvm_header->ImageChecksum))
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_IMG_CHECKSUM, filename, module);
}
return (-1);
}
offset += length;
extent -= length;
module++;
}
while (~nvm_header->NextHeader);
if (extent)
{
if (_allclr (flags, NVM_SILENCE))
{
error (0, errno, NVM_HDR_LINK, filename, module);
}
}
return (0);
}
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_hdr ethernet;
struct qualcomm_hdr 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 (&request->ethernet, source, target, channel->type);
QualcommHeader (&request->qualcomm, 0, 41036);
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 0
/*
* This causes a multi-device session to terminate if the device has recently
* been removed or powered-off; The device appears to be present but will not
* respond; Also, this terminates a session if the network is overloaded with
* traffic;
*/
if (ReadMME (plc, 0, 41037) <= 0)
{
error (1, errno, CHANNEL_CANTREAD);
}
#endif
sleep (plc->timer);
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 [])
{
static char const * optv [] =
{
"eqv",
"pibfile",
"Atheros Classification Rule Dump Utility",
"e\tredirect stderr messages to stdout",
"q\tquiet mode",
"v\tverbose mode",
(char const *) (0)
};
struct auto_connection auto_connection [PIB_MAX_AUTOCONN];
struct classifier_priority_map classifier_priority_map [PIB_MAX_PRIORITY_MAPS];
uint32_t AutoConnection_count;
uint32_t PriorityMaps_count;
unsigned i;
flag_t flags = (flag_t)(0);
struct _file_ pib;
signed c;
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'e':
dup2 (STDOUT_FILENO, STDERR_FILENO);
break;
case 'q':
_setbits (flags, PIB_SILENCE);
break;
case 'v':
_setbits (flags, PIB_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
while ((argc) && (* argv))
{
pib.name = * argv;
if ((pib.file = open (pib.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", pib.name);
}
if (pibfile1 (&pib))
{
error (1, errno, "Bad PIB file: %s", pib.name);
}
if (lseek (pib.file, PIB_AUTOCONN_COUNT_OFFSET, SEEK_SET) != PIB_AUTOCONN_COUNT_OFFSET)
{
error (1, errno, "could not seek to AutoConnection count");
}
if (read (pib.file, &AutoConnection_count, sizeof (AutoConnection_count)) != sizeof (AutoConnection_count))
{
error (1, errno, "could not read AutoConnection count");
}
if (lseek (pib.file, PIB_AUTOCONN_OFFSET, SEEK_SET) != PIB_AUTOCONN_OFFSET)
{
error (1, errno, "could not seek to AutoConnections");
}
if (read (pib.file, &auto_connection, sizeof (auto_connection)) != sizeof (auto_connection))
{
error (1, errno, "could not read AutoConnections");
}
if (lseek (pib.file, PIB_PRIORITY_COUNT_OFFSET, SEEK_SET) != PIB_PRIORITY_COUNT_OFFSET)
{
error (1, errno, "could not seek to PriorityMaps count");
}
if (read (pib.file, &PriorityMaps_count, sizeof (PriorityMaps_count)) != sizeof (PriorityMaps_count))
{
error (1, errno, "could not read PriorityMaps count");
}
if (lseek (pib.file, PIB_PRIORITY_MAPS_OFFSET, SEEK_SET) != PIB_PRIORITY_MAPS_OFFSET)
{
error (1, errno, "could not seek to Priority Map");
}
if (read (pib.file, &classifier_priority_map, sizeof (classifier_priority_map)) != sizeof (classifier_priority_map))
{
error (1, errno, "could not read Priority Map");
}
close (pib.file);
if (_allclr (flags, PIB_SILENCE))
{
printf ("# auto connection rules:\n");
}
for (i = 0; i < AutoConnection_count; ++i)
{
AutoConnection (&auto_connection [i]);
}
if (_allclr (flags, PIB_SILENCE))
{
printf ("# priority mapping rules:\n");
}
for (i = 0; i < PriorityMaps_count; ++i)
{
ClassifierPriorityMap (&classifier_priority_map [i]);
}
argv++;
argc--;
}
exit (0);
}
static void function (file const * file, off_t extent, flag_t flags)
{
unsigned object = 0;
unsigned lineno = 0;
unsigned offset = 0;
unsigned length = 0;
char memory [_ADDRSIZE + 1];
char symbol [_NAMESIZE];
char string [_LINESIZE];
char * sp;
signed c;
while ((c = getc (stdin)) != EOF)
{
if ((c == '#') || (c == ';'))
{
do
{
c = getc (stdin);
}
while (nobreak (c));
lineno++;
continue;
}
if (isspace (c))
{
if (c == '\n')
{
lineno++;
}
continue;
}
length = 0;
while (isdigit (c))
{
length *= 10;
length += c - '0';
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
sp = symbol;
if (isalpha (c) || (c == '_'))
{
do
{
* sp++ = (char) (c);
c = getc (stdin);
}
while (isident (c));
}
while (isblank (c))
{
c = getc (stdin);
}
if (c == '[')
{
* sp++ = (char) (c);
c = getc (stdin);
while (isblank (c))
{
c = getc (stdin);
}
while (isdigit (c))
{
* sp++ = (char) (c);
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
* sp = (char) (0);
if (c != ']')
{
error (1, EINVAL, "Have '%s' without ']' on line %d", symbol, lineno);
}
* sp++ = (char) (c);
c = getc (stdin);
}
* sp = (char) (0);
while (isblank (c))
{
c = getc (stdin);
}
sp = string;
while (nobreak (c))
{
* sp++ = (char) (c);
c = getc (stdin);
}
* sp = (char) (0);
if (length)
{
byte buffer [length];
if (read (file->file, buffer, length) == (signed) (length))
{
if (! object++)
{
for (c = 0; c < _ADDRSIZE + 65; c++)
{
putc ('-', stdout);
}
putc ('\n', stdout);
}
printf ("%s %u %s\n", hexoffset (memory, sizeof (memory), offset), length, symbol);
hexview (buffer, offset, length, stdout);
for (c = 0; c < _ADDRSIZE + 65; c++)
{
putc ('-', stdout);
}
putc ('\n', stdout);
}
}
offset += length;
lineno++;
}
if (_allclr (flags, ODD_SILENCE))
{
if (offset != (unsigned) (extent))
{
error (0, 0, "%s has %u bytes, not " OFF_T_SPEC " bytes.", file->name, offset, extent);
}
}
return;
}
int main (int argc, char const * argv [])
{
static char const * optv [] =
{
"counts the lines, words, chars and bytes in a text file",
PUTOPTV_S_FUNNEL,
"W:lwcbt",
"W s\tcharset is (s) [" CHRLIB_WORDSET "]",
"l\tdisplay line count",
"w\tdisplay word count",
"c\tdisplay char count",
"b\tdisplay byte count",
"t\tdisplay totals",
(char const *) (0)
};
struct wc total =
{
0,
0,
0,
0,
"total"
};
static char words [UCHAR_MAX + 1];
static char table [UCHAR_MAX + 1];
flag_t flags = (flag_t) (0);
signed c;
total._name = "total";
memset (table, 0, sizeof (table));
charset (CHRLIB_WORDSET, (char) (0), words, sizeof (words));
chrdef (table, words);
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'W':
memset (table, 0, sizeof (table));
charset (optarg, (char) (0), words, sizeof (words));
chrdef (table, words);
break;
case 'l':
_setbits (flags, WC_B_NLINE);
break;
case 'w':
_setbits (flags, WC_B_NWORD);
break;
case 'c':
_setbits (flags, WC_B_NCHAR);
break;
case 'b':
_setbits (flags, WC_B_NBYTE);
break;
case 't':
_setbits (flags, WC_B_TOTAL);
break;
default:
break;
}
}
if (_allclr (flags, WC_B_NLINE | WC_B_NWORD | WC_B_NCHAR | WC_B_NBYTE))
{
_setbits (flags, WC_B_NLINE | WC_B_NWORD | WC_B_NCHAR | WC_B_NBYTE);
}
argc -= optind;
argv += optind;
if (! argc)
{
function ("stdin", table, & total, flags);
}
while ((argc) && (* argv))
{
if (efreopen (* argv, "rb", stdin))
{
function (* argv, table, & total, flags);
}
argc--;
argv++;
}
show (& total, flags);
exit (0);
}
static void pibdump (struct _file_ const * file, char const * schema, unsigned extent, flag_t flags)
{
unsigned offset = 0;
signed indent = 0;
signed length = 0;
unsigned lineno = 1;
char symbol [0x0100];
char string [0x0400];
char * sp;
signed c;
output (indent++, "<%s xmlns:xsi='%s' xsi:noNamespaceSchemaLocation='%s'>", DATA_OBJECT, XML_NAMESPACE, schema);
while ((c = getc (stdin)) != EOF)
{
if ((c == '#') || (c == ';'))
{
do
{
c = getc (stdin);
}
while (nobreak (c));
}
if (isspace (c))
{
if (c == '\n')
{
lineno++;
}
continue;
}
while (isdigit (c))
{
length *= 10;
length += c - '0';
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
sp = symbol;
if (isalpha (c) || (c == '_'))
{
do
{
*sp++ = (char)(c);
c = getc (stdin);
}
while (isident (c));
}
*sp = (char)(0);
while (isblank (c))
{
c = getc (stdin);
}
if (c == '[')
{
#if 0
*sp++ = (char)(c);
#endif
c = getc (stdin);
while (isblank (c))
{
c = getc (stdin);
}
while (isdigit (c))
{
#if 0
*sp++ = (char)(c);
#endif
c = getc (stdin);
}
while (isblank (c))
{
c = getc (stdin);
}
if (c != ']')
{
error (1, EINVAL, "Have '%c' but need ']'", c);
}
#if 0
*sp++ = (char)(c);
#endif
c = getc (stdin);
}
*sp = (char)(0);
while (isblank (c))
{
c = getc (stdin);
}
sp = string;
while (nobreak (c))
{
*sp++ = (char)(c);
c = getc (stdin);
}
*sp = (char)(0);
if (length > 0)
{
#if defined (WIN32)
byte * buffer = (byte *)(emalloc (length));
#else
byte buffer [length];
#endif
if (read (file->file, buffer, length) == length)
{
output (indent++, "<%s name='%s'>", DATA_MEMBER, symbol);
#if 0
if (*string)
{
output (indent++, "<text>");
output (indent, "%s", string);
output (indent--, "</text>");
}
#endif
output (indent++, "<%s>", DATA_OFFSET);
output (indent, "%04X", offset);
output (indent--, "</%s>", DATA_OFFSET);
output (indent++, "<%s>", DATA_LENGTH);
output (indent, "%d", length);
output (indent--, "</%s>", DATA_LENGTH);
output (indent++, "<%s>", DATA_MEMORY);
for (c = 0; c < indent; c++)
{
printf ("\t");
}
for (c = 0; c < length; c++)
{
printf ("%02X", buffer [c]);
}
printf ("\n");
output (indent--, "</%s>", DATA_MEMORY);
output (indent--, "</%s>", DATA_MEMBER);
}
#if defined (WIN32)
free (buffer);
#endif
}
offset += length;
length = 0;
}
output (indent--, "</%s>", DATA_OBJECT);
if (_allclr (flags, PIB_SILENCE))
{
if (offset != extent)
{
error (0, 0, "file %s is %d not %d bytes", file->name, extent, offset);
}
}
return;
}
int main (int argc, char const * argv [])
{
static char const * optv [] =
{
"list folders or links or standard files",
"path [path] [...] [> stdout]",
"c:dflnw:",
"c n\tcolumn count is (n) [" LITERAL (COUNT) "]",
"d\tlist directory files",
"f\tlist standard files",
"l\tlist symbolic links",
"w n\tscreen width is (n) [" LITERAL (WIDTH) "]",
"n\tnumber items",
(char const *) (0)
};
char filename [FILENAME_MAX];
bool index = false;
flag_t flags = (flag_t) (0);
size_t width = WIDTH;
size_t count = COUNT;
signed c;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'd':
_clrbits (flags, FIND_B_REG);
_clrbits (flags, FIND_B_LNK);
_setbits (flags, FIND_B_DIR);
break;
case 'l':
_clrbits (flags, FIND_B_REG);
_setbits (flags, FIND_B_LNK);
_clrbits (flags, FIND_B_DIR);
break;
case 'f':
_setbits (flags, FIND_B_REG);
_clrbits (flags, FIND_B_LNK);
_clrbits (flags, FIND_B_DIR);
break;
case 'n':
index = true;
break;
case 'w':
width = uintspec (optarg, 1, 132);
break;
case 'c':
count = uintspec (optarg, 1, 16);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (flags, (FIND_B_ALL)))
{
_setbits (flags, FIND_B_DIR);
}
if (! argc)
{
strcpy (filename, getenv ("PWD"));
function (filename, filename, width, count, index, flags);
}
while ((argc) && (* argv))
{
strcpy (filename, * argv);
function (filename, filename, width, count, index, flags);
argc--;
argv++;
}
exit (0);
}
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 [])
{
struct sigaction sa;
struct ifreq ifreq;
struct sockaddr_ll sockaddr =
{
PF_PACKET,
htons (ETH_P_HPAV),
0x0000,
ARPHRD_ETHER,
PACKET_OTHERHOST,
ETHER_ADDR_LEN,
{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00
}
};
static char const * optv [] =
{
"di:qv",
PUTOPTV_S_DIVINE,
"Qualcomm Atheros HomePlug AV Packet Daemon",
"d\trun in background as daemon",
"i s\thost interface is (s) [" ETHDEVICE "]",
"q\tsuppress normal output",
"v\tverbose messages on stdout",
(char const *) (0)
};
uint8_t packet [ETHER_MAX_LEN];
flag_t state = (flag_t)(0);
flag_t flags = (flag_t)(0);
sock_t fd = -1;
signed c;
memset (&ifreq, 0, sizeof (ifreq));
memcpy (ifreq.ifr_name, ETHDEVICE, sizeof (ETHDEVICE));
if (getenv (PLCDEVICE))
{
memcpy (ifreq.ifr_name, getenv (PLCDEVICE), sizeof (ifreq.ifr_name));
}
optind = 1;
while ((c = getoptv (argc, argv, optv)) != -1)
{
switch ((char) (c))
{
case 'd':
_setbits (flags, HPAVD_DAEMON);
break;
case 'i':
memcpy (ifreq.ifr_name, optarg, sizeof (ifreq.ifr_name));
break;
case 'q':
_setbits (flags, HPAVD_SILENCE);
break;
case 'v':
_setbits (flags, HPAVD_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (geteuid ())
{
error (1, EPERM, ERROR_NOTROOT);
}
if (_anyset (flags, HPAVD_DAEMON))
{
pid_t pid = fork ();
if (pid < 0)
{
error (1, errno, "razzlefrats!");
}
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));
if ((fd = socket (sockaddr.sll_family, SOCK_RAW, sockaddr.sll_protocol)) == -1)
{
error (1, errno, "Can't create socket for %s", ifreq.ifr_name);
}
if (ioctl (fd, SIOCGIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't read %s device state", ifreq.ifr_name);
}
state = ifreq.ifr_flags;
_setbits (ifreq.ifr_flags, (IFF_UP | IFF_BROADCAST));
_clrbits (ifreq.ifr_flags, (IFF_MULTICAST | IFF_ALLMULTI | IFF_PROMISC));
if (ioctl (fd, SIOCSIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't change %s device state", ifreq.ifr_name);
}
if (ioctl (fd, SIOCGIFINDEX, &ifreq) == -1)
{
error (1, errno, "Can't get %s interface index", ifreq.ifr_name);
}
sockaddr.sll_ifindex = ifreq.ifr_ifindex;
if (ioctl (fd, SIOCGIFHWADDR, &ifreq) == -1)
{
error (1, errno, "Can't get %s hardware address", ifreq.ifr_name);
}
memcpy (sockaddr.sll_addr, ifreq.ifr_ifru.ifru_hwaddr.sa_data, sizeof (sockaddr.sll_addr));
if (bind (fd, (struct sockaddr *) (&sockaddr), sizeof (struct sockaddr_ll)) == -1)
{
error (1, errno, "Can't bind socket to %s", ifreq.ifr_name);
}
while (!done)
{
signed length = recvfrom (fd, packet, sizeof (packet), 0, (struct sockaddr *) (0), (socklen_t *)(0));
if (length > 0)
{
if (_allclr (flags, HPAVD_SILENCE))
{
MMEPeek (&packet, length, stdout);
}
if (_anyset (flags, HPAVD_VERBOSE))
{
hexdump (&packet, 0, length, stdout);
}
}
}
ifreq.ifr_flags = state;
if (ioctl (fd, SIOCSIFFLAGS, &ifreq) < 0)
{
error (1, errno, "Can't restore %s device state", ifreq.ifr_name);
}
close (fd);
return (0);
}
int main (int argc, char const * argv [])
{
extern const unsigned char ct_unescape [];
static char const * optv [] =
{
"print user/group names in alphabetcial order in columns",
PUTOPTV_S_DIVINE,
"c:e:gHnw:uRT",
"c n\tcolumn count is (n) [" LITERAL (COUNT) "]",
"w n\tscreen width is (n) [" LITERAL (WIDTH) "]",
"e s\texpression is s [.+]",
"g\tlist groupnames",
"H\tregular expression help",
"u\tlist usernames",
"n\tnumber list items",
"R\tregular expression help",
"T\tescape sequence rules",
(char *) (0)
};
LIST list;
regexp * regex = (regexp *) (0);
char const * expression = ".+";
flag_t flags = (flag_t) (0);
size_t count = COUNT;
size_t width = WIDTH;
bool index = false;
int c;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'w':
width = uintspec (optarg, 1, 132);
break;
case 'c':
count = uintspec (optarg, 1, 16);
break;
case 'g':
_setbits (flags, WHOM_B_GRP);
break;
case 'e':
expression = optarg;
break;
case 'n':
index = true;
break;
case 'u':
_setbits (flags, WHOM_B_USR);
break;
case 'H':
_setbits (flags, WHOM_B_SHW);
break;
case 'R':
regexhelp ();
exit (0);
case 'T':
chruescmap (ct_unescape, REGEX_C_ESC);
exit (0);
default:
break;
}
}
argc -= optind;
argv += optind;
if (_anyset (flags, (WHOM_B_SHW)))
{
regex = regexmake (expression);
regexshow (regex);
return (0);
}
if (_allclr (flags, (WHOM_B_USR | WHOM_B_GRP)))
{
_setbits (flags, (WHOM_B_USR | WHOM_B_GRP));
}
setpwent ();
listcreate (& list, _LISTSIZE);
regex = regexmake (expression);
function (& list, regex, flags);
regex = regexfree (regex);
listcolumn (& list, stdout, width, count, index);
listdelete (& list);
endpwent ();
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);
}
signed ExecuteApplets1 (struct plc * plc)
{
unsigned module = 0;
struct nvm_header1 nvm_header;
if (lseek (plc->NVM.file, 0, SEEK_SET))
{
if (_allclr (plc->flags, PLC_SILENCE))
{
error (PLC_EXIT (plc), errno, FILE_CANTHOME, plc->NVM.name);
}
return (-1);
}
do
{
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
if (_allclr (plc->flags, PLC_SILENCE))
{
error (PLC_EXIT (plc), errno, NVM_HDR_CANTREAD, plc->NVM.name, module);
}
return (-1);
}
if (LE32TOH (nvm_header.HEADERVERSION) != 0x60000000)
{
if (_allclr (plc->flags, PLC_SILENCE))
{
error (PLC_EXIT (plc), 0, NVM_HDR_VERSION, plc->NVM.name, module);
}
return (-1);
}
if (checksum32 (&nvm_header, sizeof (nvm_header), 0))
{
if (_allclr (plc->flags, PLC_SILENCE))
{
error (PLC_EXIT (plc), 0, NVM_HDR_CHECKSUM, plc->NVM.name, module);
}
return (-1);
}
if (plc->hardwareID < CHIPSET_AR7400)
{
if (WriteFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (StartFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
}
else
{
if (WriteExecuteFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
}
if (_anyset (plc->flags, PLC_QUICK_FLASH))
{
break;
}
while (!ReadMME (plc, 0, (VS_HOST_ACTION | MMTYPE_IND)));
module++;
}
while (nvm_header.NEXTHEADER);
return (0);
}
int main (int argc, char const * argv [])
{
extern FIND find;
static char const * optv [] =
{
"copy remote files to local folder",
"folder findspec [findspec] [...]",
"o:qrv",
"q\tquiet (don't report failures)",
"r\trecursive search",
"v\tverbose (report successes)",
(char const *) (0)
};
FIND home;
flag_t flags = (flag_t) (0);
signed c;
while (~ (c = getoptv (argc, argv, optv)))
{
switch (c)
{
case 'r':
_setbits (find.flagword, FIND_B_RECURSE);
break;
case 'q':
_clrbits (flags, IMPORT_SILENCE);
break;
case 'v':
_setbits (flags, IMPORT_VERBOSE);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (_allclr (find.flagword, (FIND_B_LNK | FIND_B_REG)))
{
_setbits (find.flagword, (FIND_B_LNK | FIND_B_REG));
}
if (argc)
{
strcpy (home.pathname, * argv);
if (lstat (home.pathname, & home.statinfo))
{
error (1, errno, FILE_CANTSTAT, * argv);
}
if (! S_ISDIR (home.statinfo.st_mode))
{
error (1, EINVAL, "%s is not a folder", * argv);
}
argc--;
argv++;
}
while ((argc) && (* argv))
{
makefind (& find, * argv);
findfile (& find, & home, flags);
argc--;
argv++;
}
exit (0);
}
