static void
parse_hostnetworkmask(const char *name, struct in_addr **addrpp,
struct in_addr *maskp, unsigned int *naddrs)
{
struct in_addr *addrp;
char buf[256];
char *p;
int i, j, k, n;
strncpy(buf, name, sizeof(buf) - 1);
if ((p = strrchr(buf, '/')) != NULL) {
*p = '\0';
addrp = parse_mask(p + 1);
} else
addrp = parse_mask(NULL);
inaddrcpy(maskp, addrp);
/* if a null mask is given, the name is ignored, like in "any/0" */
if (maskp->s_addr == 0L)
strcpy(buf, "0.0.0.0");
addrp = *addrpp = parse_hostnetwork(buf, naddrs);
n = *naddrs;
for (i = 0, j = 0; i < n; i++) {
addrp[j++].s_addr &= maskp->s_addr;
for (k = 0; k < j - 1; k++) {
if (addrp[k].s_addr == addrp[j - 1].s_addr) {
(*naddrs)--;
j--;
break;
}
}
}
}
int8_t parse_pci_command(struct pci_command *dest, const char *str)
{
const char *err;
uint64_t shift;
dest->flags = parse_print_flag(&str, str);
dest->bus = parse_pci_id8(&str, str);
if (!str || *str++ != '.')
return -1;
dest->device = parse_pci_id8(&str, str);
if (!str || *str++ != '.')
return -1;
dest->function = parse_pci_id8(&str, str);
if (!str || *str++ != '.')
return -1;
dest->offset = parse_pci_id16(&str, str);
if (!str)
return -1;
dest->mask = parse_mask(&str, str);
if (!str)
return -1;
shift = 0;
while (((dest->mask >> shift) & 1) == 0)
shift++;
dest->shift = shift;
dest->value = parse_value(&err, str);
if (err != str) {
dest->value <<= shift;
if ((dest->value & dest->mask) != dest->value)
return -1;
dest->flags |= PCI_COMMAND_WRITE;
str = err;
}
if (*str == '\0')
return 0;
return -1;
}
cmd_result_t
test_mode(int u, args_t *a)
/*
* Function: test_mode
* Purpose: Set test test mode
* Parameters: [+/-] "soe" or "stoponerror"
* Returns: 0 - success,
* -1 - failed.
*/
{
static parse_pm_t options[] = {
{"@SOE", TEST_O_SOE},
{"@AOE", TEST_O_AOE},
{"Stoponerror", TEST_O_SOE},
{"Abortonerror",TEST_O_AOE},
{"Quiet", TEST_O_QUIET},
{"Progress", TEST_O_PROGRESS},
{"RANDom", TEST_O_RANDOM},
{"SIlent", TEST_O_SILENT},
{"Run", TEST_O_RUN},
{"Override", TEST_O_OVERRIDE},
{"NoReinit", TEST_O_NO_REINIT},
{NULL, 0}
};
char *c;
COMPILER_REFERENCE(u);
if (0 == ARG_CNT(a)) {
cli_out("Test: Options: ");
parse_mask_format(80, options, test_options);
cli_out("\n");
return(CMD_OK);
}
while ((c = ARG_GET(a)) != NULL) {
if (parse_mask(c, options, &test_options)) {
cli_out("%s: Error: invalid option ignored: %s\n", ARG_CMD(a), c);
}
}
return(CMD_OK);
}
static int toenum(lua_State *L, int idx, lbind_Enum *et, int mask, int check) {
int type = lua_type(L, idx);
if (type == LUA_TNUMBER)
return lua_tointeger(L, idx);
else if (type == LUA_TSTRING) {
size_t len;
const char *s = lua_tolstring(L, idx, &len);
int value;
if (!mask) {
lbind_EnumItem *item = lbind_findenum(et, s, len);
if (item == NULL && check)
return luaL_error(L, "invalid %s value: %s", et->name, s);
if (item != NULL)
return item->value;
}
else if (parse_mask(et, s, &value, check ? L : NULL))
return value;
}
if (check)
lbind_typeerror(L, idx, et->name);
return -1;
}
int main(int argc, char *argv[])
{
int optind;
int debug = 0, dont_send = 0;
unsigned int src_mask = 0, src_value = 0;
unsigned int dest_mask = 0, dest_value = 0;
unsigned int srcport_mask = 0, srcport_value = 0;
unsigned int destport_mask = 0, destport_value = 0;
short swport = JUNK;
unsigned char Xflag = 0, Aflag = 0;
char* bind_addr = 0;
int multicast_port = -1;
char* type = 0;
/* Get the action */
char *action = argv[1];
progname = basename(argv[0]);
/* Check the arguments */
if (argc < 4 || action == NULL) {
fprintf(stderr, "\nThe action, -b and -s are required.\n");
usage();
exit(1);
}
if (!(strcmp(action, "add") == 0 || strcmp(action, "delete") == 0)) {
fprintf(stderr, "\nUnknown action \"%s\"\n", action);
usage();
exit(1);
}
optind = 2; /* We've handled two arguments */
while (optind < argc) {
char* option = argv[optind];
char* optarg = argv[optind + 1];
optind++;
if (*option != '-') {
fprintf(stderr, "\nExpected option instead of \"%s\"\n", option);
usage();
exit(1);
}
if (strcmp(option, "-d") == 0 || strcmp(option, "-v") == 0) {
debug++;
continue;
}
else if (strcmp(option, "-X") == 0)
Xflag++;
else if (strcmp(option, "-n") == 0)
dont_send++;
else if (strcmp(option, "-A") == 0)
Aflag++;
else {
optind++; /* All others take an argument */
if (*optarg == 0) {
fprintf(stderr, "\nOption \"%s\" requires an argument.\n",
option);
usage();
exit(1);
}
if (strcmp(option, "-b") == 0)
bind_addr = optarg;
else if (strcmp(option, "-p") == 0)
multicast_port = atoi(optarg);
else if (strcmp(option, "-s") == 0)
swport = strtoul(optarg, 0, 0);
else if (strcmp(option, "-t") == 0)
type = optarg;
else if (strcmp(option, "-src") == 0)
parse_mask(optarg, &src_mask, &src_value);
else if (strcmp(option, "-dest") == 0)
parse_mask(optarg, &dest_mask, &dest_value);
else if (strcmp(option, "-srcport") == 0)
parse_mask(optarg, &srcport_mask, &srcport_value);
else if (strcmp(option, "-destport") == 0)
parse_mask(optarg, &destport_mask, &destport_value);
else
fprintf(stderr, "\nOption \"%s\" unrecognized, skipping.\n",
option);
}
}
if (!Aflag && !Xflag && (swport == JUNK || swport < 0)) {
fprintf(stderr, "\nSwitch port must be specified and non-negative.\n");
usage();
exit(1);
}
if (swport >= 32) {
fprintf(stderr, "Switch port must be between 0 and 31 (inclusive)\n.");
usage();
exit(1);
}
if (bind_addr == 0) {
fprintf(stderr, "Address to bind to (-b) must be specified.\n");
usage();
exit(1);
}
if (Xflag)
swport = NULL_PORT;
if (Aflag)
swport = ACCEPT;
if (znl2_send_rule(action, type, multicast_port, bind_addr,
src_mask, src_value, dest_mask, dest_value,
srcport_mask, srcport_value,
destport_mask, destport_value,
swport, progname, debug, dont_send) < 0) {
fprintf(stderr, "%s: error trying to send multicast message.\n",
progname);
exit(2);
}
exit(0);
}
static int parse_masks( Lexer* lexer, cfx2_List** list_ptr )
{
cfx2_List* list;
cfx2_Mask* mask;
int error;
list = 0;
for ( ; ; )
{
Token next;
error = parse_mask( lexer, &mask );
if ( error )
return error;
if ( mask )
{
if ( !list )
{
list = new_list();
if ( !list )
{
release_mask( mask );
return cfx2_alloc_error;
}
}
list_add( list, mask );
}
else
{
if ( list )
{
release_mask_list( list );
error = cfx2_syntax_error;
lexer->input->handle_error( lexer->input, error, lexer->line, "Unexpected '*' near TODO" );
return error;
}
*list_ptr = 0;
return cfx2_ok;
}
/* if a ',' follows, continue parsing the masks */
error = lexer_get_current( lexer, &next );
if ( error == cfx2_EOF || ( !error && next.type != T_comma ) )
break;
else if ( error )
return error;
error = lexer_read( lexer, &next );
if ( error )
return error;
}
*list_ptr = list;
return cfx2_ok;
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
load_defaults("my",load_default_groups,&argc,&argv);
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_waiter.trace";
#endif
#ifndef _WIN32
// Catching signal to allow testing of EINTR safeness
// with "while killall -USR1 ndbwaiter; do true; done"
signal(SIGUSR1, catch_signal);
#endif
if (handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option))
return NDBT_ProgramExit(NDBT_WRONGARGS);
const char* connect_string = argv[0];
if (connect_string == 0)
connect_string = opt_ndb_connectstring;
enum ndb_mgm_node_status wait_status;
if (_no_contact)
{
wait_status= NDB_MGM_NODE_STATUS_NO_CONTACT;
}
else if (_not_started)
{
wait_status= NDB_MGM_NODE_STATUS_NOT_STARTED;
}
else if (_single_user)
{
wait_status= NDB_MGM_NODE_STATUS_SINGLEUSER;
}
else
{
wait_status= NDB_MGM_NODE_STATUS_STARTED;
}
if (_nowait_nodes)
{
int res = parse_mask(_nowait_nodes, nowait_nodes_bitmask);
if(res == -2 || (res > 0 && nowait_nodes_bitmask.get(0)))
{
ndbout_c("Invalid nodeid specified in nowait-nodes: %s",
_nowait_nodes);
exit(-1);
}
else if (res < 0)
{
ndbout_c("Unable to parse nowait-nodes argument: %s",
_nowait_nodes);
exit(-1);
}
}
if (_wait_nodes)
{
if (_nowait_nodes)
{
ndbout_c("Can not set both wait-nodes and nowait-nodes.");
exit(-1);
}
int res = parse_mask(_wait_nodes, nowait_nodes_bitmask);
if (res == -2 || (res > 0 && nowait_nodes_bitmask.get(0)))
{
ndbout_c("Invalid nodeid specified in wait-nodes: %s",
_wait_nodes);
exit(-1);
}
else if (res < 0)
{
ndbout_c("Unable to parse wait-nodes argument: %s",
_wait_nodes);
exit(-1);
}
// Don't wait for any other nodes than the ones we have set explicitly
nowait_nodes_bitmask.bitNOT();
}
if (waitClusterStatus(connect_string, wait_status) != 0)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
cmd_result_t
cmd_ipfix(int unit, args_t *arg)
{
char *subcmd;
parse_table_t pt;
bcm_ipfix_config_t config;
int rv, i;
int port = 0;
bcm_ip_t src_ip4_mask = 0, dst_ip4_mask = 0;
bcm_ip_t tunnel_src_ip4_mask = 0, tunnel_dst_ip4_mask = 0;
bcm_ip6_t src_ip6_mask, dst_ip6_mask;
bcm_ip6_t tunnel_src_ip6_mask, tunnel_dst_ip6_mask;
int enable_l2 = 0, enable_ip4 = 0, enable_ip6 = 0;
int record_non_discard = 1, record_discard = 0, check_flow_end = 0;
int use_l2_for_ip4 = 0, use_l2_for_ip6 = 0;
int key_src_ip = 0, key_dst_ip = 0;
int key_ip_prot = 0, key_ip_dscp = 0, key_ip_ecn = 0;
int key_l4_src_port = 0, key_l4_dst_port = 0, key_ip6_flow = 0;
int key_icmp_type = 0, key_icmp_code = 0, key_macda = 0, key_macsa = 0;
int key_vlan_id = 0, key_vlan_pri = 0, key_ether_type = 0;
int key_vlan_tagged = 0, key_source_port = 0;
int stage = 0, dscp_idx = 0, entry_limit = 8191;
int min_time = 0, max_time = 0;
int max_idle_time = 32767, sample_rate = 1;
char str[IP6ADDR_STR_LEN];
if (!ARG_CNT(arg)) { /* Nothing passed */
cli_out("IPFIX Deamon Status: %s.\n",
(ipfix_is_running[unit]) ? "Running" : "Not Running");
cli_out("Reporting is enabled for: ");
parse_mask_format(80, ipfix_report_table, ipfix_report[unit]);
cli_out("Reporting is disabled for: ");
parse_mask_format(80, ipfix_report_table, ipfix_report[unit] ^ ~0);
cli_out("Number of records received: %d\n", ipfix_report_count[unit]);
return(CMD_OK);
}
subcmd = ARG_GET(arg);
if (subcmd == NULL) {
return CMD_USAGE;
}
rv = BCM_E_NONE;
sal_memset(src_ip6_mask, 0, sizeof(bcm_ip6_t));
sal_memset(dst_ip6_mask, 0, sizeof(bcm_ip6_t));
sal_memset(tunnel_src_ip6_mask, 0, sizeof(bcm_ip6_t));
sal_memset(tunnel_dst_ip6_mask, 0, sizeof(bcm_ip6_t));
if (!sal_strcasecmp(subcmd, "start")) {
if (ipfix_is_running[unit]) {
cli_out("%s: IPFIX thread already running.\n", ARG_CMD(arg));
return CMD_OK;
}
ipfix_report_count[unit] = 0;
ipfix_is_running[unit] = 1;
rv = bcm_ipfix_export_fifo_control(unit, 1000000);
if (rv < 0) {
cli_out("%s: ERROR: %s\n", ARG_CMD(arg), bcm_errmsg(rv));
return CMD_FAIL;
}
rv = bcm_ipfix_register(unit, _ipfix_callback, NULL);
} else if (!sal_strcasecmp(subcmd, "stop")) {
if (!ipfix_is_running[unit]) {
cli_out("%s: ERROR: IPFIX thread already stopped.\n", ARG_CMD(arg));
return CMD_FAIL;
}
ipfix_is_running[unit] = 0;
rv = bcm_ipfix_export_fifo_control(unit, 0);
if (rv < 0) {
cli_out("%s: ERROR: %s\n", ARG_CMD(arg), bcm_errmsg(rv));
return CMD_FAIL;
}
rv = bcm_ipfix_unregister(unit, _ipfix_callback, NULL);
} else if (!sal_strcasecmp(subcmd, "set")) {
parse_table_init(unit, &pt);
parse_table_add(&pt, "Port", PQ_DFL | PQ_INT, (void *)-1, &port, 0);
parse_table_add(&pt, "Stage", PQ_DFL | PQ_INT, (void *)0, &stage, 0);
parse_table_add(&pt, "EnableL2", PQ_DFL | PQ_INT, (void *)0,
&enable_l2, 0);
parse_table_add(&pt, "EnableIp4", PQ_DFL | PQ_INT, (void *)0,
&enable_ip4, 0);
parse_table_add(&pt, "EnableIp6", PQ_DFL | PQ_INT, (void *)0,
&enable_ip6, 0);
parse_table_add(&pt, "RecordNonDiscard", PQ_DFL | PQ_INT, (void *)0,
&record_non_discard, 0);
parse_table_add(&pt, "RecordDiscard", PQ_DFL | PQ_INT, (void *)0,
&record_discard, 0);
parse_table_add(&pt, "CheckFlowEnd", PQ_DFL | PQ_INT, (void *)0,
&check_flow_end, 0);
parse_table_add(&pt, "UseL2ForIp4", PQ_DFL | PQ_INT, (void *)0,
&use_l2_for_ip4, 0);
parse_table_add(&pt, "UseL2ForIp6", PQ_DFL | PQ_INT, (void *)0,
&use_l2_for_ip6, 0);
parse_table_add(&pt, "KeySrcIp", PQ_DFL | PQ_INT, (void *)0,
&key_src_ip, 0);
parse_table_add(&pt, "KeyIpProt", PQ_DFL | PQ_INT, (void *)0,
&key_ip_prot, 0);
parse_table_add(&pt, "KeyIpDscp", PQ_DFL | PQ_INT, (void *)0,
&key_ip_dscp, 0);
parse_table_add(&pt, "KeyIpEcn", PQ_DFL | PQ_INT, (void *)0,
&key_ip_ecn, 0);
parse_table_add(&pt, "KeyDstIp", PQ_DFL | PQ_INT, (void *)0,
&key_dst_ip, 0);
parse_table_add(&pt, "KeyIpEcn", PQ_DFL | PQ_INT, (void *)0,
&key_ip_ecn, 0);
parse_table_add(&pt, "KeyL4SrcPort", PQ_DFL | PQ_INT, (void *)0,
&key_l4_src_port, 0);
parse_table_add(&pt, "KeyL4DstPort", PQ_DFL | PQ_INT, (void *)0,
&key_l4_dst_port, 0);
parse_table_add(&pt, "KeyIp6Flow", PQ_DFL | PQ_INT, (void *)0,
&key_ip6_flow, 0);
parse_table_add(&pt, "KeyIcmpType", PQ_DFL | PQ_INT, (void *)0,
&key_icmp_type, 0);
parse_table_add(&pt, "KeyIcmpCode", PQ_DFL | PQ_INT, (void *)0,
&key_icmp_code, 0);
parse_table_add(&pt, "KeyMacDa", PQ_DFL | PQ_INT, (void *)0,
&key_macda, 0);
parse_table_add(&pt, "KeyMacSa", PQ_DFL | PQ_INT, (void *)0,
&key_macsa, 0);
parse_table_add(&pt, "KeyVlanId", PQ_DFL | PQ_INT, (void *)0,
&key_vlan_id, 0);
parse_table_add(&pt, "KeyVlanPri", PQ_DFL | PQ_INT, (void *)0,
&key_vlan_pri, 0);
parse_table_add(&pt, "KeyEtherType", PQ_DFL | PQ_INT, (void *)0,
&key_ether_type, 0);
parse_table_add(&pt, "KeyVlanTagged", PQ_DFL | PQ_INT, (void *)0,
&key_vlan_tagged, 0);
parse_table_add(&pt, "KeySourcePort", PQ_DFL | PQ_INT, (void *)0,
&key_source_port, 0);
parse_table_add(&pt, "Ip4SrcMask", PQ_DFL | PQ_IP, 0, &src_ip4_mask,
0);
parse_table_add(&pt, "Ip4DstMask", PQ_DFL | PQ_IP, 0, &dst_ip4_mask,
0);
parse_table_add(&pt, "TunnelIp4SrcMask", PQ_DFL | PQ_IP, 0,
&tunnel_src_ip4_mask, 0);
parse_table_add(&pt, "TunnelIp4DstMask", PQ_DFL | PQ_IP, 0,
&tunnel_dst_ip4_mask, 0);
parse_table_add(&pt, "Ip6SrcMask", PQ_DFL | PQ_IP6, 0, &src_ip6_mask,
0);
parse_table_add(&pt, "Ip6DstMask", PQ_DFL | PQ_IP6, 0, &dst_ip6_mask,
0);
parse_table_add(&pt, "TunnelIp6SrcMask", PQ_DFL | PQ_IP6, 0,
&tunnel_src_ip6_mask, 0);
parse_table_add(&pt, "TunnelIp6DstMask", PQ_DFL | PQ_IP6, 0,
&tunnel_dst_ip6_mask, 0);
parse_table_add(&pt, "DscpMap", PQ_DFL | PQ_MULTI, 0, &dscp_idx,
dscp_names);
parse_table_add(&pt, "Limit", PQ_DFL | PQ_INT, (void *)0,
&entry_limit, 0);
parse_table_add(&pt, "MinTime", PQ_DFL | PQ_INT, (void *)0,
&min_time, 0);
parse_table_add(&pt, "MaxTime", PQ_DFL | PQ_INT, (void *)0,
&max_time, 0);
parse_table_add(&pt, "MaxIdleTime", PQ_DFL | PQ_INT, (void *)0,
&max_idle_time, 0);
parse_table_add(&pt, "SampleRate", PQ_DFL | PQ_INT, (void *)0,
&sample_rate, 0);
if (parse_arg_eq(arg, &pt) < 0) {
parse_arg_eq_done(&pt);
return CMD_USAGE;
}
parse_arg_eq_done(&pt);
sal_memset(&config, 0, sizeof(config));
config.flags |= enable_l2 ? BCM_IPFIX_CONFIG_ENABLE_NON_IP : 0;
config.flags |= enable_ip4 ? BCM_IPFIX_CONFIG_ENABLE_IP4 : 0;
config.flags |= enable_ip6 ? BCM_IPFIX_CONFIG_ENABLE_IP6 : 0;
config.flags |= check_flow_end ? BCM_IPFIX_CONFIG_TCP_END_DETECT : 0;
config.flags |= record_non_discard ?
BCM_IPFIX_CONFIG_RECORD_NON_DISCARD_PKT : 0;
config.flags |= record_discard ?
BCM_IPFIX_CONFIG_RECORD_DISCARD_PKT : 0;
config.flags |= use_l2_for_ip4 ? BCM_IPFIX_CONFIG_KEY_IP4_USE_L2 : 0;
config.flags |= use_l2_for_ip6 ? BCM_IPFIX_CONFIG_KEY_IP6_USE_L2 : 0;
config.flags |= key_src_ip ? BCM_IPFIX_CONFIG_KEY_SRC_IP : 0;
config.flags |= key_dst_ip ? BCM_IPFIX_CONFIG_KEY_DST_IP : 0;
config.flags |= key_ip_prot ? BCM_IPFIX_CONFIG_KEY_IP_PROT : 0;
config.flags |= key_ip_dscp ? BCM_IPFIX_CONFIG_KEY_IP_DSCP : 0;
config.flags |= key_ip_ecn ? BCM_IPFIX_CONFIG_KEY_IP_ECN : 0;
config.flags |= key_l4_src_port ? BCM_IPFIX_CONFIG_KEY_L4_SRC_PORT : 0;
config.flags |= key_l4_dst_port ? BCM_IPFIX_CONFIG_KEY_L4_DST_PORT : 0;
config.flags |= key_ip6_flow ? BCM_IPFIX_CONFIG_KEY_IP6_FLOW : 0;
config.flags |= key_icmp_type ? BCM_IPFIX_CONFIG_KEY_ICMP_TYPE : 0;
config.flags |= key_icmp_code ? BCM_IPFIX_CONFIG_KEY_ICMP_CODE : 0;
config.flags |= key_macda ? BCM_IPFIX_CONFIG_KEY_MACDA : 0;
config.flags |= key_macsa ? BCM_IPFIX_CONFIG_KEY_MACSA : 0;
config.flags |= key_vlan_id ? BCM_IPFIX_CONFIG_KEY_VLAN_ID : 0;
config.flags |= key_vlan_pri ? BCM_IPFIX_CONFIG_KEY_VLAN_PRI : 0;
config.flags |= key_ether_type ? BCM_IPFIX_CONFIG_KEY_ETHER_TYPE : 0;
config.flags |= key_vlan_tagged ? BCM_IPFIX_CONFIG_KEY_VLAN_TAGGED : 0;
config.flags |= key_source_port ?
BCM_IPFIX_CONFIG_KEY_SOURCE_PORT_OR_INTERFACE : 0;
if (dscp_idx == 0) {
for (i = 0; i < 64; i++) {
config.dscp_mask[i] = i;
}
} else {
for (i = 0; i < 64; i++) {
config.dscp_mask[i] = 0;
}
}
config.src_ip4_mask = src_ip4_mask;
config.dst_ip4_mask = dst_ip4_mask;
config.tunnel_src_ip4_mask = tunnel_src_ip4_mask;
config.tunnel_dst_ip4_mask = tunnel_dst_ip4_mask;
SAL_IP6_ADDR_TO_UINT32(src_ip6_mask, (uint32 *)config.src_ip6_mask);
SAL_IP6_ADDR_TO_UINT32(dst_ip6_mask, (uint32 *)config.dst_ip6_mask);
SAL_IP6_ADDR_TO_UINT32(tunnel_src_ip6_mask,
(uint32 *)config.tunnel_src_ip6_mask);
SAL_IP6_ADDR_TO_UINT32(tunnel_dst_ip6_mask,
(uint32 *)config.tunnel_dst_ip6_mask);
config.entry_limit = entry_limit;
config.min_time = min_time;
config.max_time = max_time;
config.max_idle_time = max_idle_time;
config.sample_rate = sample_rate;
rv = bcm_ipfix_config_set(unit, stage, port, &config);
} else if (!sal_strcasecmp(subcmd, "get")) {
parse_table_init(unit, &pt);
parse_table_add(&pt, "Port", PQ_DFL | PQ_INT, (void *)-1, &port, 0);
parse_table_add(&pt, "Stage", PQ_DFL | PQ_INT, (void *)0, &stage, 0);
if (parse_arg_eq(arg, &pt) < 0) {
parse_arg_eq_done(&pt);
return CMD_USAGE;
}
parse_arg_eq_done(&pt);
rv = bcm_ipfix_config_get(unit, stage, port, &config);
if (rv >= 0) {
if (config.flags & BCM_IPFIX_CONFIG_ENABLE_NON_IP) {
cli_out("BCM_IPFIX_CONFIG_ENABLE_NON_IP\n");
}
if (config.flags & BCM_IPFIX_CONFIG_ENABLE_IP4) {
cli_out("BCM_IPFIX_CONFIG_ENABLE_IP4\n");
}
if (config.flags & BCM_IPFIX_CONFIG_ENABLE_IP6) {
cli_out("BCM_IPFIX_CONFIG_ENABLE_IP6\n");
}
if (config.flags & BCM_IPFIX_CONFIG_TCP_END_DETECT) {
cli_out("BCM_IPFIX_CONFIG_TCP_END_DETECT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_RECORD_NON_DISCARD_PKT) {
cli_out("BCM_IPFIX_CONFIG_RECORD_NON_DISCARD_PKT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_RECORD_DISCARD_PKT) {
cli_out("BCM_IPFIX_CONFIG_RECORD_DISCARD_PKT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP4_USE_L2) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP4_USE_L2\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP6_USE_L2) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP6_USE_L2\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_SRC_IP) {
cli_out("BCM_IPFIX_CONFIG_KEY_SRC_IP\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_DST_IP) {
cli_out("BCM_IPFIX_CONFIG_KEY_DST_IP\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP_PROT) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP_PROT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP_DSCP) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP_DSCP\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP_ECN) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP_ECN\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_L4_SRC_PORT) {
cli_out("BCM_IPFIX_CONFIG_KEY_L4_SRC_PORT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_L4_DST_PORT) {
cli_out("BCM_IPFIX_CONFIG_KEY_L4_DST_PORT\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_IP6_FLOW) {
cli_out("BCM_IPFIX_CONFIG_KEY_IP6_FLOW\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_ICMP_TYPE) {
cli_out("BCM_IPFIX_CONFIG_KEY_ICMP_TYPE\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_ICMP_CODE) {
cli_out("BCM_IPFIX_CONFIG_KEY_ICMP_CODE\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_MACDA) {
cli_out("BCM_IPFIX_CONFIG_KEY_MACDA\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_MACSA) {
cli_out("BCM_IPFIX_CONFIG_KEY_MACSA\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_VLAN_ID) {
cli_out("BCM_IPFIX_CONFIG_KEY_VLAN_ID\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_VLAN_PRI) {
cli_out("BCM_IPFIX_CONFIG_KEY_VLAN_PRI\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_ETHER_TYPE) {
cli_out("BCM_IPFIX_CONFIG_KEY_ETHER_TYPE\n");
}
if (config.flags & BCM_IPFIX_CONFIG_KEY_VLAN_TAGGED) {
cli_out("BCM_IPFIX_CONFIG_KEY_VLAN_TAGGED\n");
}
if (config.flags & BCM_IPFIX_CONFIG_TCP_FLAGS_LAST) {
cli_out("BCM_IPFIX_CONFIG_TCP_FLAGS_LAST\n");
}
cli_out("entry_limit=%d min_time=%d max_time=%d\n",
config.entry_limit, config.min_time, config.max_time);
cli_out("max_idle_time=%d sample_rate=%d\n",
config.max_idle_time, config.sample_rate);
format_ipaddr(str, config.src_ip4_mask);
cli_out("src_ip4_mask %s\n", str);
format_ipaddr(str, config.dst_ip4_mask);
cli_out("dst_ip4_mask %s\n", str);
format_ip6addr(str, config.src_ip6_mask);
cli_out("src_ip6_mask %s\n", str);
format_ip6addr(str, config.dst_ip6_mask);
cli_out("dst_ip6_mask %s\n", str);
}
} else if (!sal_strcasecmp(subcmd, "report")) {
if (ARG_CNT(arg)) {
while ((subcmd = ARG_CUR(arg)) != NULL &&
!parse_mask(subcmd, ipfix_report_table, &ipfix_report[unit])) {
ARG_NEXT(arg); /* Bump arg if matched report */
}
} else { /* Print values */
cli_out("IPFIX Reporting on for: ");
parse_mask_format(50, ipfix_report_table, ipfix_report[unit]);
cli_out("IPFIX Reporting off for: ");
parse_mask_format(50, ipfix_report_table, ~ipfix_report[unit]);
}
} else {
return CMD_USAGE;
}
if (rv < 0) {
cli_out("%s: ERROR: %s\n", ARG_CMD(arg), bcm_errmsg(rv));
return CMD_FAIL;
}
return CMD_OK;
}
static int mgmd_main(int argc, char** argv)
{
NDB_INIT(argv[0]);
printf("MySQL Cluster Management Server %s\n", NDB_VERSION_STRING);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
load_defaults("my",load_default_groups,&argc,&argv);
defaults_argv= argv; /* Must be freed by 'free_defaults' */
int ho_error;
#ifndef DBUG_OFF
opt_debug= IF_WIN("d:t:i:F:o,c:\\ndb_mgmd.trace",
"d:t:i:F:o,/tmp/ndb_mgmd.trace");
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
mgmd_exit(ho_error);
if (opts.interactive ||
opts.non_interactive ||
opts.print_full_config) {
opts.daemon= 0;
}
if (opts.mycnf && opts.config_filename)
{
fprintf(stderr, "ERROR: Both --mycnf and -f is not supported\n");
mgmd_exit(1);
}
if (opt_nowait_nodes)
{
int res = parse_mask(opt_nowait_nodes, opts.nowait_nodes);
if(res == -2 || (res > 0 && opts.nowait_nodes.get(0)))
{
fprintf(stderr, "ERROR: Invalid nodeid specified in nowait-nodes: '%s'\n",
opt_nowait_nodes);
mgmd_exit(1);
}
else if (res < 0)
{
fprintf(stderr, "ERROR: Unable to parse nowait-nodes argument: '%s'\n",
opt_nowait_nodes);
mgmd_exit(1);
}
}
/* Setup use of event logger */
g_eventLogger->setCategory(opt_logname);
/* Output to console initially */
g_eventLogger->createConsoleHandler();
#ifdef _WIN32
/* Output to Windows event log */
g_eventLogger->createEventLogHandler("MySQL Cluster Management Server");
#endif
if (opts.verbose)
g_eventLogger->enable(Logger::LL_ALL); // --verbose turns on everything
/**
Install signal handler for SIGPIPE
Done in TransporterFacade as well.. what about Configretriever?
*/
#if !defined NDB_WIN32
signal(SIGPIPE, SIG_IGN);
#endif
while (!g_StopServer)
{
mgm= new MgmtSrvr(opts);
if (mgm == NULL) {
g_eventLogger->critical("Out of memory, couldn't create MgmtSrvr");
mgmd_exit(1);
}
/* Init mgm, load or fetch config */
if (!mgm->init()) {
delete mgm;
mgmd_exit(1);
}
if (NdbDir::chdir(NdbConfig_get_path(NULL)) != 0)
{
g_eventLogger->warning("Cannot change directory to '%s', error: %d",
NdbConfig_get_path(NULL), errno);
// Ignore error
}
if (opts.daemon)
{
NodeId localNodeId= mgm->getOwnNodeId();
if (localNodeId == 0) {
g_eventLogger->error("Couldn't get own node id");
delete mgm;
mgmd_exit(1);
}
char *lockfile= NdbConfig_PidFileName(localNodeId);
char *logfile= NdbConfig_StdoutFileName(localNodeId);
if (ndb_daemonize(lockfile, logfile))
{
g_eventLogger->error("Couldn't start as daemon, error: '%s'",
ndb_daemon_error);
mgmd_exit(1);
}
}
/* Start mgm services */
if (!mgm->start()) {
delete mgm;
mgmd_exit(1);
}
if (opts.interactive) {
int port= mgm->getPort();
BaseString con_str;
if(opts.bind_address)
con_str.appfmt("host=%s:%d", opts.bind_address, port);
else
con_str.appfmt("localhost:%d", port);
Ndb_mgmclient com(con_str.c_str(), 1);
while(!g_StopServer) {
if (!read_and_execute(&com, "ndb_mgm> ", 1))
g_StopServer = true;
}
}
else
{
g_eventLogger->info("MySQL Cluster Management Server %s started",
NDB_VERSION_STRING);
while (!g_StopServer)
NdbSleep_MilliSleep(500);
}
g_eventLogger->info("Shutting down server...");
delete mgm;
g_eventLogger->info("Shutdown complete");
if(g_RestartServer) {
g_eventLogger->info("Restarting server...");
g_RestartServer= g_StopServer= false;
}
}
mgmd_exit(0);
return 0;
}
/** =========================================================================
*/
static int
report_error(mysql_connection_t *conn, char *mask_str)
{
int rc = 0;
unsigned int num_fields;
unsigned int num_rows, i;
MYSQL_RES *res;
MYSQL_ROW row;
mask_val_t *mask_vals = parse_mask(mask_str);
if (QUERY(conn,
"select pe.SymbolErrors, pe.LinkRecovers,"
" pe.LinkDowned, pe.RcvErrors, pe.RcvRemotePhysErrors,"
" pe.RcvSwitchRelayErrors, pe.XmtDiscards,"
" pe.XmtConstraintErrors, pe.RcvConstraintErrors,"
" pe.LinkIntegrityErrors, pe.ExcBufOverrunErrors,"
" pe.VL15Dropped, n.name, pe.port, n.guid,"
" pd.xmit_data, pd.rcv_data, pd.xmit_pkts, pd.rcv_pkts,"
" pd.unicast_xmit_pkts, pd.unicast_rcv_pkts,"
" pd.multicast_xmit_pkts, pd.multicast_rcv_pkts, "
" pd.port "
" from "
" port_errors as pe,nodes as n,port_data_counters as pd "
" where"
" n.guid=pe.guid and n.guid=pd.guid and pe.port=pd.port;"
)) {
fprintf(stderr, "Failed to query node errors\n");
return (1);
}
res = mysql_store_result(conn->conn);
if ((num_fields = mysql_num_fields(res)) != 24) {
fprintf(stderr, "%s:%d Failed to query node errors %d != 24\n",
__FUNCTION__, __LINE__, num_fields);
rc = 1;
goto free_res;
}
num_rows = mysql_num_rows(res);
if (num_rows == 0) {
fprintf(stderr, "Failed to find any nodes in DB\n");
rc = 1;
goto free_res;
}
for (i = 0; i < num_rows; i++) {
uint64_t SymbolErrors;
uint64_t LinkRecovers;
uint64_t LinkDowned;
uint64_t RcvErrors;
uint64_t RcvRemotePhysErrors;
uint64_t RcvSwitchRelayErrors;
uint64_t XmtDiscards;
uint64_t XmtConstraintErrors;
uint64_t RcvConstraintErrors;
uint64_t LinkIntegrityErrors;
uint64_t ExcBufOverrunErrors;
uint64_t VL15Dropped;
uint64_t total = 0;
row = mysql_fetch_row(res);
SymbolErrors = COL_TO_UINT64(0);
total += CHECK_MASK(SymbolErrors, mask_vals);
LinkRecovers = COL_TO_UINT64(1);
total += CHECK_MASK(LinkRecovers, mask_vals);
LinkDowned = COL_TO_UINT64(2);
total += CHECK_MASK(LinkDowned, mask_vals);
RcvErrors = COL_TO_UINT64(3);
total += CHECK_MASK(RcvErrors, mask_vals);
RcvRemotePhysErrors = COL_TO_UINT64(4);
total += CHECK_MASK(RcvRemotePhysErrors, mask_vals);
RcvSwitchRelayErrors = COL_TO_UINT64(5);
total += CHECK_MASK(RcvSwitchRelayErrors, mask_vals);
XmtDiscards = COL_TO_UINT64(6);
total += CHECK_MASK(XmtDiscards, mask_vals);
XmtConstraintErrors = COL_TO_UINT64(7);
total += CHECK_MASK(XmtConstraintErrors, mask_vals);
RcvConstraintErrors = COL_TO_UINT64(8);
total += CHECK_MASK(RcvConstraintErrors, mask_vals);
LinkIntegrityErrors = COL_TO_UINT64(9);
total += CHECK_MASK(LinkIntegrityErrors, mask_vals);
ExcBufOverrunErrors = COL_TO_UINT64(10);
total += CHECK_MASK(ExcBufOverrunErrors, mask_vals);
VL15Dropped = COL_TO_UINT64(11);
total += CHECK_MASK(VL15Dropped, mask_vals);
if (total > 0) {
char node_desc[65];
char *node_name = NULL;
strncpy(node_desc, row[12], 64);
node_name = remap_node_name(node_name_map, COL_TO_UINT64(14), node_desc);
print_report_error_res(node_name, row, total);
free(node_name);
}
}
free_res:
mysql_free_result(res);
return (rc);
}
