release/src-rt/emf/emfconf/emfu.c

   1 /*
   2  * EMFL Command Line Utility: This utility can be used to start/stop
   3  * EMF, enable/disable BSS forwarding, add/delete/list the Static
   4  * MFDB entries.
   5  *
   6  * Copyright (C) 2010, Broadcom Corporation
   7  * All Rights Reserved.
   8  *
   9  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
  10  * the contents of this file may not be disclosed to third parties, copied
  11  * or duplicated in any form, in whole or in part, without the prior
  12  * written permission of Broadcom Corporation.
  13  *
  14  * $Id: emfu.c 241182 2011-02-17 21:50:03Z gmo $
  15  */
  16 #include <stdio.h>
  17 #include <sys/types.h>
  18 #include <typedefs.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <netinet/in.h>
  25 #include <shutils.h>
  26 #include <emf_cfg.h>
  27 #include "emfu.h"
  28 #if defined(linux)
  29 #include "emfu_linux.h"
  30 #include <arpa/inet.h>
  31 #else /* defined(vxworks) */
  32 #error "Unsupported osl"
  33 #endif
  34
  35 #define MAX_DATA_SIZE  sizeof(emf_cfg_request_t)
  36
  37 static int emf_cfg_enable(char *argv[]);
  38 static int emf_cfg_disable(char *argv[]);
  39 static int emf_cfg_status_get(char *argv[]);
  40 static int emf_cfg_bridge_add(char *argv[]);
  41 static int emf_cfg_bridge_del(char *argv[]);
  42 static int emf_cfg_iface_add(char *argv[]);
  43 static int emf_cfg_iface_del(char *argv[]);
  44 static int emf_cfg_iface_list(char *argv[]);
  45 static int emf_cfg_uffp_add(char *argv[]);
  46 static int emf_cfg_uffp_del(char *argv[]);
  47 static int emf_cfg_uffp_list(char *argv[]);
  48 static int emf_cfg_mfdb_add(char *argv[]);
  49 static int emf_cfg_mfdb_del(char *argv[]);
  50 static int emf_cfg_mfdb_clear(char *argv[]);
  51 static int emf_cfg_mfdb_list(char *argv[]);
  52 static int emf_cfg_stats_show(char *argv[]);
  53
  54 static emf_cmd_arg_t cmd_args[] =
  55 {
  56         {
  57                 "start",
  58                 NULL,
  59                 emf_cfg_enable,
  60                 EMF_ARGC_ENABLE_FWD
  61         },
  62         {
  63                 "stop",
  64                 NULL,
  65                 emf_cfg_disable,
  66                 EMF_ARGC_DISABLE_FWD
  67         },
  68         {
  69                 "status",
  70                 NULL,
  71                 emf_cfg_status_get,
  72                 EMF_ARGC_GET_FWD
  73         },
  74         {
  75                 "add",
  76                 "bridge",
  77                 emf_cfg_bridge_add,
  78                 EMF_ARGC_ADD_BRIDGE
  79         },
  80         {
  81                 "del",
  82                 "bridge",
  83                 emf_cfg_bridge_del,
  84                 EMF_ARGC_DEL_BRIDGE
  85         },
  86         {
  87                 "add",
  88                 "iface",
  89                 emf_cfg_iface_add,
  90                 EMF_ARGC_ADD_IF
  91         },
  92         {
  93                 "del",
  94                 "iface",
  95                 emf_cfg_iface_del,
  96                 EMF_ARGC_DEL_IF
  97         },
  98         {
  99                 "list",
 100                 "iface",
 101                 emf_cfg_iface_list,
 102                 EMF_ARGC_LIST_IF
 103         },
 104         {
 105                 "add",
 106                 "uffp",
 107                 emf_cfg_uffp_add,
 108                 EMF_ARGC_ADD_UFFP
 109         },
 110         {
 111                 "del",
 112                 "uffp",
 113                 emf_cfg_uffp_del,
 114                 EMF_ARGC_DEL_UFFP
 115         },
 116         {
 117                 "list",
 118                 "uffp",
 119                 emf_cfg_uffp_list,
 120                 EMF_ARGC_LIST_UFFP
 121         },
 122         {
 123                 "add",
 124                 "rtport",
 125                 emf_cfg_uffp_add,
 126                 EMF_ARGC_ADD_RTPORT
 127         },
 128         {
 129                 "del",
 130                 "rtport",
 131                 emf_cfg_uffp_del,
 132                 EMF_ARGC_DEL_RTPORT
 133         },
 134         {
 135                 "list",
 136                 "rtport",
 137                 emf_cfg_uffp_list,
 138                 EMF_ARGC_LIST_RTPORT
 139         },
 140         {
 141                 "add",
 142                 "mfdb",
 143                 emf_cfg_mfdb_add,
 144                 EMF_ARGC_ADD_MFDB
 145         },
 146         {
 147                 "del",
 148                 "mfdb",
 149                 emf_cfg_mfdb_del,
 150                 EMF_ARGC_DEL_MFDB
 151         },
 152         {
 153                 "clear",
 154                 "mfdb",
 155                 emf_cfg_mfdb_clear,
 156                 EMF_ARGC_CLEAR_MFDB
 157         },
 158         {
 159                 "list",
 160                 "mfdb",
 161                 emf_cfg_mfdb_list,
 162                 EMF_ARGC_LIST_MFDB
 163         },
 164         {
 165                 "show",
 166                 "stats",
 167                 emf_cfg_stats_show,
 168                 EMF_ARGC_SHOW_STATS
 169         }
 170 };
 171
 172 static void
 173 emf_usage(FILE *fid)
 174 {
 175         fprintf(fid, EMF_USAGE);
 176         return;
 177 }
 178
 179 static int
 180 emf_cfg_enable(char *argv[])
 181 {
 182         emf_cfg_request_t req;
 183
 184         bzero((char *)&req, sizeof(emf_cfg_request_t));
 185
 186         strcpy((char *)req.inst_id, argv[2]);
 187         req.command_id = EMFCFG_CMD_EMF_ENABLE;
 188         req.size = sizeof(bool);
 189         req.oper_type = EMFCFG_OPER_TYPE_SET;
 190         *(bool *)req.arg = TRUE;
 191
 192         /* Send request to kernel */
 193         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 194         {
 195                 fprintf(stderr, "Unable to send request to EMF\n");
 196                 return (FAILURE);
 197         }
 198
 199         if (req.status != EMFCFG_STATUS_SUCCESS)
 200         {
 201                 fprintf(stderr, "%s\n", req.arg);
 202                 return (FAILURE);
 203         }
 204
 205         return (SUCCESS);
 206 }
 207
 208 static int
 209 emf_cfg_disable(char *argv[])
 210 {
 211         emf_cfg_request_t req;
 212
 213         bzero((char *)&req, sizeof(emf_cfg_request_t));
 214
 215         strcpy((char *)req.inst_id, argv[2]);
 216         req.command_id = EMFCFG_CMD_EMF_ENABLE;
 217         req.size = sizeof(bool);
 218         req.oper_type = EMFCFG_OPER_TYPE_SET;
 219         *(bool *)req.arg = FALSE;
 220
 221         /* Send request to kernel */
 222         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 223         {
 224                 fprintf(stderr, "Unable to send request to EMF\n");
 225                 return (FAILURE);
 226         }
 227
 228         if (req.status != EMFCFG_STATUS_SUCCESS)
 229         {
 230                 fprintf(stderr, "%s\n", req.arg);
 231                 return (FAILURE);
 232         }
 233
 234         return (SUCCESS);
 235 }
 236
 237 static int
 238 emf_cfg_status_get(char *argv[])
 239 {
 240         emf_cfg_request_t req;
 241
 242         bzero((char *)&req, sizeof(emf_cfg_request_t));
 243
 244         strcpy((char *)req.inst_id, argv[2]);
 245         req.command_id = EMFCFG_CMD_EMF_ENABLE;
 246         req.oper_type = EMFCFG_OPER_TYPE_GET;
 247
 248         /* Send request to kernel */
 249         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 250         {
 251                 fprintf(stderr, "Unable to send request to EMF\n");
 252                 return (FAILURE);
 253         }
 254
 255         if (req.status != EMFCFG_STATUS_SUCCESS)
 256         {
 257                 fprintf(stderr, "%sUnable to read Multicast forwarding status\n", req.arg);
 258                 return (FAILURE);
 259         }
 260
 261         fprintf(stdout, "Multicast forwarding status: %s",
 262                 (*(bool *)req.arg ? "ENABLED\n" : "DISABLED\n"));
 263
 264         return (SUCCESS);
 265 }
 266
 267 static int
 268 emf_cfg_bridge_add(char *argv[])
 269 {
 270         emf_cfg_request_t req;
 271
 272         bzero((char *)&req, sizeof(emf_cfg_request_t));
 273
 274         strcpy((char *)req.inst_id, argv[3]);
 275         req.command_id = EMFCFG_CMD_BR_ADD;
 276         req.oper_type = EMFCFG_OPER_TYPE_SET;
 277
 278         /* Send request to kernel */
 279         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 280         {
 281                 fprintf(stderr, "Unable to send request to EMF\n");
 282                 return (FAILURE);
 283         }
 284
 285         if (req.status != EMFCFG_STATUS_SUCCESS)
 286         {
 287                 fprintf(stderr, "%s\n", req.arg);
 288                 return (FAILURE);
 289         }
 290
 291         return (SUCCESS);
 292 }
 293
 294 static int
 295 emf_cfg_bridge_del(char *argv[])
 296 {
 297         emf_cfg_request_t req;
 298
 299         bzero((char *)&req, sizeof(emf_cfg_request_t));
 300
 301         strcpy((char *)req.inst_id, argv[3]);
 302         req.command_id = EMFCFG_CMD_BR_DEL;
 303         req.oper_type = EMFCFG_OPER_TYPE_SET;
 304
 305         /* Send request to kernel */
 306         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 307         {
 308                 fprintf(stderr, "Unable to send request to EMF\n");
 309                 return (FAILURE);
 310         }
 311
 312         if (req.status != EMFCFG_STATUS_SUCCESS)
 313         {
 314                 fprintf(stderr, "%s\n", req.arg);
 315                 return (FAILURE);
 316         }
 317
 318         return (SUCCESS);
 319 }
 320
 321 static int
 322 emf_cfg_iface_add(char *argv[])
 323 {
 324         emf_cfg_request_t req;
 325         emf_cfg_if_t *cfg_if;
 326
 327         bzero((char *)&req, sizeof(emf_cfg_request_t));
 328
 329         strcpy((char *)req.inst_id, argv[3]);
 330         req.command_id = EMFCFG_CMD_IF_ADD;
 331         req.oper_type = EMFCFG_OPER_TYPE_SET;
 332
 333         cfg_if = (emf_cfg_if_t *)req.arg;
 334         strncpy((char *)cfg_if->if_name, argv[4], 16);
 335         cfg_if->if_name[15] = 0;
 336
 337         /* Send request to kernel */
 338         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 339         {
 340                 fprintf(stderr, "Unable to send request to EMF\n");
 341                 return (FAILURE);
 342         }
 343
 344         if (req.status != EMFCFG_STATUS_SUCCESS)
 345         {
 346                 fprintf(stderr, "%s\n", req.arg);
 347                 return (FAILURE);
 348         }
 349
 350         return (SUCCESS);
 351 }
 352
 353 static int
 354 emf_cfg_iface_del(char *argv[])
 355 {
 356         emf_cfg_request_t req;
 357         emf_cfg_if_t *cfg_if;
 358
 359         bzero((char *)&req, sizeof(emf_cfg_request_t));
 360
 361         strcpy((char *)req.inst_id, argv[3]);
 362         req.command_id = EMFCFG_CMD_IF_DEL;
 363         req.oper_type = EMFCFG_OPER_TYPE_SET;
 364
 365         cfg_if = (emf_cfg_if_t *)req.arg;
 366         strncpy((char *)cfg_if->if_name, argv[4], 16);
 367         cfg_if->if_name[15] = 0;
 368
 369         /* Send request to kernel */
 370         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 371         {
 372                 fprintf(stderr, "Unable to send request to EMF\n");
 373                 return (FAILURE);
 374         }
 375
 376         if (req.status != EMFCFG_STATUS_SUCCESS)
 377         {
 378                 fprintf(stderr, "%s\n", req.arg);
 379                 return (FAILURE);
 380         }
 381
 382         return (SUCCESS);
 383 }
 384
 385 static int
 386 emf_cfg_iface_list(char *argv[])
 387 {
 388         emf_cfg_request_t req;
 389         emf_cfg_if_list_t *list;
 390         int32 i;
 391
 392         bzero((char *)&req, sizeof(emf_cfg_request_t));
 393
 394         strcpy((char *)req.inst_id, argv[3]);
 395         req.command_id = EMFCFG_CMD_IF_LIST;
 396         req.oper_type = EMFCFG_OPER_TYPE_GET;
 397         req.size = sizeof(req.arg);
 398
 399         /* Send request to kernel */
 400         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 401         {
 402                 fprintf(stderr, "Unable to send request to EMF\n");
 403                 return (FAILURE);
 404         }
 405
 406         if (req.status != EMFCFG_STATUS_SUCCESS)
 407         {
 408                 fprintf(stderr, "%s\n", req.arg);
 409                 return (FAILURE);
 410         }
 411
 412         fprintf(stdout, "EMF enabled interfaces on %s: ", argv[3]);
 413
 414         list = (emf_cfg_if_list_t *)req.arg;
 415         for (i = 0; i < list->num_entries; i++)
 416         {
 417                 fprintf(stdout, "%s ", list->if_entry[i].if_name);
 418         }
 419
 420         fprintf(stdout, "\n");
 421
 422         return (SUCCESS);
 423 }
 424
 425 static int
 426 emf_cfg_uffp_add(char *argv[])
 427 {
 428         emf_cfg_request_t req;
 429         emf_cfg_uffp_t *cfg_uffp;
 430         emf_cfg_rtport_t *cfg_rtport;
 431
 432         bzero((char *)&req, sizeof(emf_cfg_request_t));
 433
 434         strcpy((char *)req.inst_id, argv[3]);
 435
 436         if (strncmp(argv[2], "uffp", 4) == 0)
 437         {
 438                 req.command_id = EMFCFG_CMD_UFFP_ADD;
 439                 cfg_uffp = (emf_cfg_uffp_t *)req.arg;
 440                 strncpy((char *)cfg_uffp->if_name, argv[4], 16);
 441                 cfg_uffp->if_name[15] = 0;
 442         }
 443         else
 444         {
 445                 req.command_id = EMFCFG_CMD_RTPORT_ADD;
 446                 cfg_rtport = (emf_cfg_rtport_t *)req.arg;
 447                 strncpy((char *)cfg_rtport->if_name, argv[4], 16);
 448                 cfg_rtport->if_name[15] = 0;
 449         }
 450
 451         req.oper_type = EMFCFG_OPER_TYPE_SET;
 452
 453         /* Send request to kernel */
 454         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 455         {
 456                 fprintf(stderr, "Unable to send request to EMF\n");
 457                 return (FAILURE);
 458         }
 459
 460         if (req.status != EMFCFG_STATUS_SUCCESS)
 461         {
 462                 fprintf(stderr, "%s\n", req.arg);
 463                 return (FAILURE);
 464         }
 465
 466         return (SUCCESS);
 467 }
 468
 469 static int
 470 emf_cfg_uffp_del(char *argv[])
 471 {
 472         emf_cfg_request_t req;
 473         emf_cfg_uffp_t *cfg_uffp;
 474         emf_cfg_rtport_t *cfg_rtport;
 475
 476         bzero((char *)&req, sizeof(emf_cfg_request_t));
 477
 478         strcpy((char *)req.inst_id, argv[3]);
 479
 480         if (strncmp(argv[2], "uffp", 4) == 0)
 481         {
 482                 req.command_id = EMFCFG_CMD_UFFP_DEL;
 483                 cfg_uffp = (emf_cfg_uffp_t *)req.arg;
 484                 strncpy((char *)cfg_uffp->if_name, argv[4], 16);
 485                 cfg_uffp->if_name[15] = 0;
 486         }
 487         else
 488         {
 489                 req.command_id = EMFCFG_CMD_RTPORT_DEL;
 490                 cfg_rtport = (emf_cfg_rtport_t *)req.arg;
 491                 strncpy((char *)cfg_rtport->if_name, argv[4], 16);
 492                 cfg_rtport->if_name[15] = 0;
 493         }
 494
 495         req.oper_type = EMFCFG_OPER_TYPE_SET;
 496
 497         /* Send request to kernel */
 498         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 499         {
 500                 fprintf(stderr, "Unable to send request to EMF\n");
 501                 return (FAILURE);
 502         }
 503
 504         if (req.status != EMFCFG_STATUS_SUCCESS)
 505         {
 506                 fprintf(stderr, "%s\n", req.arg);
 507                 return (FAILURE);
 508         }
 509
 510         return (SUCCESS);
 511 }
 512
 513 static int
 514 emf_cfg_uffp_list(char *argv[])
 515 {
 516         emf_cfg_request_t req;
 517         emf_cfg_uffp_list_t *uffp_list;
 518         emf_cfg_rtport_list_t *rtport_list;
 519         int32 i;
 520
 521         bzero((char *)&req, sizeof(emf_cfg_request_t));
 522
 523         strcpy((char *)req.inst_id, argv[3]);
 524
 525         if (strncmp(argv[2], "uffp", 4) == 0)
 526                 req.command_id = EMFCFG_CMD_UFFP_LIST;
 527         else
 528                 req.command_id = EMFCFG_CMD_RTPORT_LIST;
 529
 530         req.oper_type = EMFCFG_OPER_TYPE_GET;
 531         req.size = sizeof(req.arg);
 532
 533         /* Send request to kernel */
 534         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 535         {
 536                 fprintf(stderr, "Unable to send request to EMF\n");
 537                 return (FAILURE);
 538         }
 539
 540         if (req.status != EMFCFG_STATUS_SUCCESS)
 541         {
 542                 fprintf(stderr, "%s\n", req.arg);
 543                 return (FAILURE);
 544         }
 545
 546         if (strncmp(argv[2], "uffp", 4) == 0)
 547         {
 548                 fprintf(stdout, "UFFP list of %s: ", argv[3]);
 549
 550                 uffp_list = (emf_cfg_uffp_list_t *)req.arg;
 551                 for (i = 0; i < uffp_list->num_entries; i++)
 552                 {
 553                         fprintf(stdout, "%s ", uffp_list->uffp_entry[i].if_name);
 554                 }
 555         }
 556         else
 557         {
 558                 fprintf(stdout, "RTPORT list of %s: ", argv[3]);
 559
 560                 rtport_list = (emf_cfg_rtport_list_t *)req.arg;
 561                 for (i = 0; i < rtport_list->num_entries; i++)
 562                 {
 563                         fprintf(stdout, "%s ", rtport_list->rtport_entry[i].if_name);
 564                 }
 565         }
 566
 567         fprintf(stdout, "\n");
 568
 569         return (SUCCESS);
 570 }
 571
 572 static int
 573 emf_cfg_mfdb_add(char *argv[])
 574 {
 575         emf_cfg_mfdb_t *mfdb_entry;
 576         emf_cfg_request_t req;
 577         struct in_addr mgrp_ip;
 578
 579         bzero((char *)&req, sizeof(emf_cfg_request_t));
 580
 581         strcpy((char *)req.inst_id, argv[3]);
 582         req.command_id = EMFCFG_CMD_MFDB_ADD;
 583         req.oper_type = EMFCFG_OPER_TYPE_SET;
 584
 585         /* Convert the multicast group address to binary data */
 586         mfdb_entry = (emf_cfg_mfdb_t *)req.arg;
 587         if (inet_aton(argv[4], &mgrp_ip) == 0)
 588         {
 589                 fprintf(stderr, "Invalid group address\n");
 590                 return (FAILURE);
 591         }
 592
 593         mfdb_entry->mgrp_ip = ntohl(mgrp_ip.s_addr);
 594         strncpy((char *)mfdb_entry->if_name, argv[5], 16);
 595
 596         /* Send request to kernel */
 597         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 598         {
 599                 fprintf(stderr, "Unable to send request to EMF\n");
 600                 return (FAILURE);
 601         }
 602
 603         if (req.status != EMFCFG_STATUS_SUCCESS)
 604         {
 605                 fprintf(stderr, "%sMFDB add failed\n", req.arg);
 606                 return (FAILURE);
 607         }
 608
 609         return (SUCCESS);
 610 }
 611
 612 static int
 613 emf_cfg_mfdb_del(char *argv[])
 614 {
 615         emf_cfg_mfdb_t *mfdb_entry;
 616         emf_cfg_request_t req;
 617         struct in_addr mgrp_ip;
 618
 619         bzero((char *)&req, sizeof(emf_cfg_request_t));
 620
 621         strcpy((char *)req.inst_id, argv[3]);
 622         req.command_id = EMFCFG_CMD_MFDB_DEL;
 623         req.oper_type = EMFCFG_OPER_TYPE_SET;
 624
 625         /* Convert the multicast group address to binary data */
 626         mfdb_entry = (emf_cfg_mfdb_t *)req.arg;
 627         if (inet_aton(argv[4], &mgrp_ip) == 0)
 628         {
 629                 fprintf(stderr, "Invalid group address\n");
 630                 return (FAILURE);
 631         }
 632
 633         mfdb_entry->mgrp_ip = ntohl(mgrp_ip.s_addr);
 634         strncpy((char *)mfdb_entry->if_name, argv[5], 16);
 635
 636         /* Send request to kernel */
 637         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 638         {
 639                 fprintf(stderr, "Unable to send request to EMF\n");
 640                 return (FAILURE);
 641         }
 642
 643         if (req.status != EMFCFG_STATUS_SUCCESS)
 644         {
 645                 fprintf(stderr, "%sMFDB delete failed\n", req.arg);
 646                 return (FAILURE);
 647         }
 648
 649         return (SUCCESS);
 650 }
 651
 652 static int
 653 emf_cfg_mfdb_clear(char *argv[])
 654 {
 655         emf_cfg_request_t req;
 656
 657         bzero((char *)&req, sizeof(emf_cfg_request_t));
 658
 659         strcpy((char *)req.inst_id, argv[3]);
 660         req.command_id = EMFCFG_CMD_MFDB_CLEAR;
 661         req.oper_type = EMFCFG_OPER_TYPE_SET;
 662
 663         /* Send request to kernel */
 664         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 665         {
 666                 fprintf(stderr, "Unable to send request to EMF\n");
 667                 return (FAILURE);
 668         }
 669
 670         if (req.status != EMFCFG_STATUS_SUCCESS)
 671         {
 672                 fprintf(stderr, "%sMFDB clear failed\n", req.arg);
 673                 return (FAILURE);
 674         }
 675
 676         return (SUCCESS);
 677 }
 678
 679 static int
 680 emf_cfg_mfdb_list(char *argv[])
 681 {
 682         emf_cfg_request_t req;
 683         emf_cfg_mfdb_list_t *list;
 684         int32 i;
 685
 686         strcpy((char *)req.inst_id, argv[3]);
 687         req.command_id = EMFCFG_CMD_MFDB_LIST;
 688         req.oper_type = EMFCFG_OPER_TYPE_GET;
 689         req.size = sizeof(req.arg);
 690         list = (emf_cfg_mfdb_list_t *)req.arg;
 691
 692         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 693         {
 694                 fprintf(stderr, "Unable to send request to EMF\n");
 695                 return (FAILURE);
 696         }
 697
 698         if (req.status != EMFCFG_STATUS_SUCCESS)
 699         {
 700                 fprintf(stderr, "Unable to get the MFBD list\n");
 701                 return (FAILURE);
 702         }
 703
 704         fprintf(stdout, "Group           Interface      Pkts\n");
 705
 706         for (i = 0; i < list->num_entries; i++)
 707         {
 708                 fprintf(stdout, "%08x        ", list->mfdb_entry[i].mgrp_ip);
 709                 fprintf(stdout, "%-15s", list->mfdb_entry[i].if_name);
 710                 fprintf(stdout, "%d\n", list->mfdb_entry[i].pkts_fwd);
 711         }
 712
 713         return (SUCCESS);
 714 }
 715
 716 static int
 717 emf_cfg_stats_show(char *argv[])
 718 {
 719         emf_cfg_request_t req;
 720         emf_stats_t *emfs;
 721
 722         strcpy((char *)req.inst_id, argv[3]);
 723         req.command_id = EMFCFG_CMD_EMF_STATS;
 724         req.oper_type = EMFCFG_OPER_TYPE_GET;
 725         req.size = sizeof(emf_stats_t);
 726         emfs = (emf_stats_t *)req.arg;
 727
 728         if (emf_cfg_request_send(&req, sizeof(emf_cfg_request_t)) < 0)
 729         {
 730                 fprintf(stderr, "Unable to send request to EMF\n");
 731                 return (FAILURE);
 732         }
 733
 734         if (req.status != EMFCFG_STATUS_SUCCESS)
 735         {
 736                 fprintf(stderr, "Unable to get the EMF stats\n");
 737                 return (FAILURE);
 738         }
 739
 740         fprintf(stdout, "McastDataPkts   McastDataFwd    McastFlooded    "
 741                 "McastDataSentUp McastDataDropped\n");
 742         fprintf(stdout, "%-15d %-15d %-15d %-15d %d\n",
 743                 emfs->mcast_data_frames, emfs->mcast_data_fwd,
 744                 emfs->mcast_data_flooded, emfs->mcast_data_sentup,
 745                 emfs->mcast_data_dropped);
 746         fprintf(stdout, "IgmpPkts        IgmpPktsFwd     "
 747                 "IgmpPktsSentUp  MFDBCacheHits   MFDBCacheMisses\n");
 748         fprintf(stdout, "%-15d %-15d %-15d %-15d %d\n",
 749                 emfs->igmp_frames, emfs->igmp_frames_fwd,
 750                 emfs->igmp_frames_sentup, emfs->mfdb_cache_hits,
 751                 emfs->mfdb_cache_misses);
 752
 753         return (SUCCESS);
 754 }
 755
 756 int
 757 #if defined(linux)
 758 main(int argc, char *argv[])
 759 #else /* defined(vxworks) */
 760 #error "Unsupported osl"
 761 #endif
 762 {
 763         int j, ret;
 764         bool cmd_syntax = FALSE;
 765
 766         if (argc < 2)
 767         {
 768                 emf_usage(stdout);
 769                 return (SUCCESS);
 770         }
 771
 772         /* Find the command type */
 773         for (j = 0; j < sizeof(cmd_args)/sizeof(cmd_args[0]); j++)
 774         {
 775                 if ((strcmp(argv[1], cmd_args[j].cmd_oper_str) == 0) &&
 776                     (argc - 1 == cmd_args[j].arg_count) &&
 777                     ((cmd_args[j].cmd_id_str == NULL) ||
 778                     ((argv[2] != NULL) &&
 779                     (strcmp(argv[2], cmd_args[j].cmd_id_str) == 0))))
 780                 {
 781                         cmd_syntax = TRUE;
 782                         break;
 783                 }
 784         }
 785
 786         if (!cmd_syntax)
 787         {
 788                 emf_usage(stdout);
 789                 return (SUCCESS);
 790         }
 791
 792         /* Call the command processing function. This function parses
 793          * prepare command request and sends it kernel.
 794          */
 795         if ((ret = cmd_args[j].input(argv)) < 0)
 796         {
 797                 return (FAILURE);
 798         }
 799
 800         return (SUCCESS);
 801 }