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",
"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;
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 [] =
{
"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;
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;
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);
}
signed ParseRule (int * argcp, char const ** argvp [], struct MMERule * rule, struct cspec * cspec)
{
int argc = * argcp;
char const ** argv = * argvp;
union
{
uint32_t wide;
uint16_t word;
uint8_t byte [4];
}
temp;
signed code;
struct MMEClassifier * classifier = (struct MMEClassifier *) (& rule->CLASSIFIER);
if ((code = lookup (* argv++, actions, SIZEOF (actions))) == -1)
{
assist (* -- argv, CLASSIFIER_ACTION_NAME, actions, SIZEOF (actions));
}
rule->MACTION = (uint8_t) (code);
argc--;
if ((code = lookup (* argv++, operands, SIZEOF (operands))) == -1)
{
assist (* -- argv, CLASSIFIER_OPERAND_NAME, operands, SIZEOF (operands));
}
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));
}
classifier->CR_PID = (uint8_t) (code);
argc--;
if ((code = lookup (* argv++, operators, SIZEOF (operators))) == -1)
{
assist (* -- argv, CLASSIFIER_OPERATOR_NAME, operators, SIZEOF (operators));
}
classifier->CR_OPERAND = (uint8_t) (code);
argc--;
if (! argc || ! * argv)
{
error (1, ENOTSUP, "I have %s '%s' but no value", CLASSIFIER_OPERATOR_NAME, * -- argv);
}
switch (classifier->CR_PID)
{
case FIELD_ETH_SA:
case FIELD_ETH_DA:
bytespec (* argv++, classifier->CR_VALUE, ETHER_ADDR_LEN);
break;
case FIELD_IPV4_SA:
case FIELD_IPV4_DA:
ipv4spec (* argv++, classifier->CR_VALUE);
break;
case FIELD_IPV6_SA:
case FIELD_IPV6_DA:
ipv6spec (* argv++, classifier->CR_VALUE);
break;
case FIELD_VLAN_UP:
case FIELD_IPV6_TC:
case FIELD_IPV4_TOS:
case FIELD_IPV4_PROT:
classifier->CR_VALUE [0] = (uint8_t) (basespec (* argv++, 0, sizeof (classifier->CR_VALUE [0])));
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:
temp.word = (uint16_t) (basespec (* argv++, 0, sizeof (temp.word)));
temp.word = htons (temp.word);
memcpy (classifier->CR_VALUE, & temp, sizeof (temp.word));
break;
case FIELD_ETH_TYPE:
temp.word = (uint16_t) (basespec (* argv++, 0, sizeof (temp.word)));
temp.word = htons (temp.word);
memcpy (classifier->CR_VALUE, & temp, sizeof (temp.word));
break;
case FIELD_IPV6_FL:
temp.wide = (uint32_t) (basespec (* argv++, 0, sizeof (temp.wide))) & 0x000FFFFF;
temp.wide = htonl (temp.wide);
memcpy (classifier->CR_VALUE, & temp.byte [1], 3);
break;
case FIELD_HPAV_MME:
bytespec (* argv++, classifier->CR_VALUE, sizeof (uint16_t) + sizeof (uint8_t));
temp.byte [0] = classifier->CR_VALUE [1];
classifier->CR_VALUE [1] = classifier->CR_VALUE [2];
classifier->CR_VALUE [2] = temp.byte [0];
break;
case FIELD_TCP_ACK:
if ((code = lookup (* argv++, states, SIZEOF (states))) == -1)
{
assist (* -- argv, CLASSIFIER_STATE_NAME, states, SIZEOF (states));
}
memset (classifier->CR_VALUE, 0, sizeof (classifier->CR_VALUE));
break;
case FIELD_VLAN_TAG:
if ((code = lookup (* argv++, states, SIZEOF (states))) == -1)
{
assist (* -- argv, CLASSIFIER_STATE_NAME, states, SIZEOF (states));
}
memset (classifier->CR_VALUE, 0, sizeof (classifier->CR_VALUE));
classifier->CR_OPERAND ^= code;
break;
default:
error (1, ENOTSUP, "%s", argv [- 2]);
break;
}
rule->NUM_CLASSIFIERS++;
classifier++;
argc--;
}
memcpy (classifier, cspec, sizeof (* cspec));
if ((code = lookup (* argv++, controls, SIZEOF (controls))) == -1)
{
assist (* -- argv, CLASSIFIER_CONTROL_NAME, controls, SIZEOF (controls));
}
rule->MCONTROL = (uint8_t) (code);
argc--;
if ((code = lookup (* argv++, volatilities, SIZEOF (volatilities))) == -1)
{
assist (* -- argv, CLASSIFIER_VOLATILITY_NAME, volatilities, SIZEOF (volatilities));
}
rule->MVOLATILITY = (uint8_t) (code);
argc--;
* argcp = argc;
* argvp = argv;
return (0);
}
size_t memencode (void * memory, size_t extent, char const * format, char const * string)
{
if (!strcmp (format, "byte"))
{
uint8_t * number = (uint8_t *)(memory);
if (extent < sizeof (* number))
{
error (1, ECANCELED, "Overflow at %s %s", format, string);
}
* number = (uint8_t)(basespec (string, 0, sizeof (* number)));
return (sizeof (* number));
}
if (!strcmp (format, "word"))
{
uint16_t * number = (uint16_t *)(memory);
if (extent < sizeof (* number))
{
error (1, ECANCELED, "Overflow at %s %s", format, string);
}
* number = (uint16_t)(basespec (string, 0, sizeof (* number)));
* number = HTOLE16 (* number);
return (sizeof (* number));
}
if (!strcmp (format, "long"))
{
uint32_t * number = (uint32_t *)(memory);
if (extent < sizeof (* number))
{
error (1, ECANCELED, "Overflow at %s %s", format, string);
}
* number = (uint32_t)(basespec (string, 0, sizeof (* number)));
* number = HTOLE32 (* number);
return (sizeof (* number));
}
if (!strcmp (format, "huge"))
{
uint64_t * number = (uint64_t *)(memory);
if (extent < sizeof (* number))
{
error (1, ECANCELED, "Overflow at %s %s", format, string);
}
* number = (uint64_t)(basespec (string, 0, sizeof (* number)));
* number = HTOLE64 (* number);
return (sizeof (* number));
}
if (!strcmp (format, "text"))
{
extent = (unsigned)(strlen (string));
memcpy (memory, string, extent);
return (extent);
}
if (!strcmp (format, "data"))
{
extent = (unsigned)(dataspec (string, memory, extent));
return (extent);
}
if (!strcmp (format, "fill"))
{
extent = (unsigned)(uintspec (string, 0, extent));
memset (memory, ~0, extent);
return (extent);
}
if (!strcmp (format, "zero"))
{
extent = (unsigned)(uintspec (string, 0, extent));
memset (memory, 0, extent);
return (extent);
}
if (!strcmp (format, "skip"))
{
extent = (unsigned)(uintspec (string, 0, extent));
return (extent);
}
#if 1
/*
* tr-069 specific fields that don't really belong in the PIB;
*/
if (!strcmp (format, "adminusername") || !strcmp (format, "adminpassword") || !strcmp (format, "accessusername"))
{
return (memstring (memory, extent, format, string, PIB_NAME_LEN + 1));
}
if (!strcmp (format, "accesspassword"))
{
return (memstring (memory, extent, format, string, PIB_HFID_LEN + 1));
}
if (!strcmp (format, "username") || !strcmp (format, "password") || !strcmp (format, "url"))
{
return (memstring (memory, extent, format, string, PIB_TEXT_LEN + 1));
}
#endif
#if 1
/*
* HPAV specific fields that belong in the PIB;
*/
if (!strcmp (format, "hfid"))
{
return (memstring (memory, extent, format, string, PIB_HFID_LEN));
}
if (!strcmp (format, "mac"))
{
return (bytespec (string, memory, ETHER_ADDR_LEN));
}
if (!strcmp (format, "key"))
{
return (bytespec (string, memory, PIB_KEY_LEN));
}
#endif
error (1, ENOTSUP, "%s", format);
return (0);
}
