release/src-rt/emf/igsconf/igsu.c

   1 /*
   2  * IGSL Command Line Utility: This utility can be used to add/remove
   3  * snooping capability on desired bridge interface.
   4  *
   5  * Copyright (C) 2010, Broadcom Corporation
   6  * All Rights Reserved.
   7  *
   8  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
   9  * the contents of this file may not be disclosed to third parties, copied
  10  * or duplicated in any form, in whole or in part, without the prior
  11  * written permission of Broadcom Corporation.
  12  *
  13  * $Id: igsu.c 241182 2011-02-17 21:50:03Z gmo $
  14  */
  15 #include <stdio.h>
  16 #include <sys/types.h>
  17 #include <typedefs.h>
  18 #include <string.h>
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <errno.h>
  23 #include <netinet/in.h>
  24 #include <arpa/inet.h>
  25 #if defined(linux)
  26 #include "igsu_linux.h"
  27 #else /* defined(vxworks) */
  28 #error "Unsupported osl"
  29 #endif
  30 #include <igs_cfg.h>
  31 #include "igsu.h"
  32
  33 #define MAX_DATA_SIZE  sizeof(igs_cfg_request_t)
  34
  35 static int igs_cfg_bridge_add(char *argv[]);
  36 static int igs_cfg_bridge_del(char *argv[]);
  37 static int igs_cfg_bridge_list(char *argv[]);
  38 static int igs_cfg_sdb_list(char *argv[]);
  39 static int igs_cfg_rtport_list(char *argv[]);
  40 static int igs_cfg_stats_show(char *argv[]);
  41
  42 static igs_cmd_arg_t cmd_args[] =
  43 {
  44         {
  45                 "add",
  46                 "bridge",
  47                 igs_cfg_bridge_add,
  48                 IGS_ARGC_ADD_BRIDGE
  49         },
  50         {
  51                 "del",
  52                 "bridge",
  53                 igs_cfg_bridge_del,
  54                 IGS_ARGC_DEL_BRIDGE
  55         },
  56         {
  57                 "list",
  58                 "bridge",
  59                 igs_cfg_bridge_list,
  60                 IGS_ARGC_LIST_BRIDGE
  61         },
  62         {
  63                 "list",
  64                 "sdb",
  65                 igs_cfg_sdb_list,
  66                 IGS_ARGC_LIST_IGSDB
  67         },
  68         {
  69                 "list",
  70                 "rtport",
  71                 igs_cfg_rtport_list,
  72                 IGS_ARGC_LIST_RTPORT
  73         },
  74         {
  75                 "show",
  76                 "stats",
  77                 igs_cfg_stats_show,
  78                 IGS_ARGC_SHOW_STATS
  79         }
  80 };
  81
  82 static void
  83 igs_usage(FILE *fid)
  84 {
  85         fprintf(fid, IGS_USAGE);
  86         return;
  87 }
  88
  89 static int
  90 igs_cfg_bridge_add(char *argv[])
  91 {
  92         igs_cfg_request_t req;
  93
  94         bzero((char *)&req, sizeof(igs_cfg_request_t));
  95
  96         strcpy((char *)req.inst_id, argv[3]);
  97         req.command_id = IGSCFG_CMD_BR_ADD;
  98         req.oper_type = IGSCFG_OPER_TYPE_SET;
  99
 100         /* Send request to kernel */
 101         if (igs_cfg_request_send(&req, sizeof(igs_cfg_request_t)) < 0)
 102         {
 103                 fprintf(stderr, "Unable to send request to IGS\n");
 104                 return (FAILURE);
 105         }
 106
 107         if (req.status != IGSCFG_STATUS_SUCCESS)
 108         {
 109                 fprintf(stderr, "%s\n", req.arg);
 110                 return (FAILURE);
 111         }
 112
 113         return (SUCCESS);
 114 }
 115
 116 static int
 117 igs_cfg_bridge_del(char *argv[])
 118 {
 119         igs_cfg_request_t req;
 120
 121         bzero((char *)&req, sizeof(igs_cfg_request_t));
 122
 123         strcpy((char *)req.inst_id, argv[3]);
 124         req.command_id = IGSCFG_CMD_BR_DEL;
 125         req.oper_type = IGSCFG_OPER_TYPE_SET;
 126
 127         /* Send request to kernel */
 128         if (igs_cfg_request_send(&req, sizeof(igs_cfg_request_t)) < 0)
 129         {
 130                 fprintf(stderr, "Unable to send request to IGS\n");
 131                 return (FAILURE);
 132         }
 133
 134         if (req.status != IGSCFG_STATUS_SUCCESS)
 135         {
 136                 fprintf(stderr, "%s\n", req.arg);
 137                 return (FAILURE);
 138         }
 139
 140         return (SUCCESS);
 141 }
 142
 143 static int
 144 igs_cfg_bridge_list(char *argv[])
 145 {
 146         fprintf(stdout, "TBD\n");
 147         return (SUCCESS);
 148 }
 149
 150 static int
 151 igs_cfg_sdb_list(char *argv[])
 152 {
 153         igs_cfg_request_t req;
 154         igs_cfg_sdb_list_t *list;
 155         bool first_row = TRUE;
 156         int32 i;
 157
 158         strcpy((char *)req.inst_id, argv[3]);
 159         req.command_id = IGSCFG_CMD_IGSDB_LIST;
 160         req.oper_type = IGSCFG_OPER_TYPE_GET;
 161         req.size = sizeof(req.arg);
 162         list = (igs_cfg_sdb_list_t *)req.arg;
 163
 164         if (igs_cfg_request_send(&req, sizeof(igs_cfg_request_t)) < 0)
 165         {
 166                 fprintf(stderr, "Unable to send request to IGS\n");
 167                 return (FAILURE);
 168         }
 169
 170         if (req.status != IGSCFG_STATUS_SUCCESS)
 171         {
 172                 fprintf(stderr, "Unable to get the IGSDB list\n");
 173                 fprintf(stderr, "%s\n", req.arg);
 174                 return (FAILURE);
 175         }
 176
 177         fprintf(stdout, "Group           Members         Interface\n");
 178
 179         for (i = 0; i < list->num_entries; i++)
 180         {
 181                 first_row = TRUE;
 182                 fprintf(stdout, "%08x        ", list->sdb_entry[i].mgrp_ip);
 183                 if (first_row)
 184                 {
 185                         fprintf(stdout, "%08x        ", list->sdb_entry[i].mh_ip);
 186                         fprintf(stdout, "%s\n", list->sdb_entry[i].if_name);
 187                         first_row = FALSE;
 188                         continue;
 189                 }
 190                 fprintf(stdout, "                ");
 191                 fprintf(stdout, "%08x        ", list->sdb_entry[i].mh_ip);
 192                 fprintf(stdout, "%s\n", list->sdb_entry[i].if_name);
 193         }
 194
 195         return (SUCCESS);
 196 }
 197
 198 static int
 199 igs_cfg_rtport_list(char *argv[])
 200 {
 201         igs_cfg_request_t req;
 202         igs_cfg_rtport_list_t *list;
 203         int32 i;
 204
 205         bzero((char *)&req, sizeof(igs_cfg_request_t));
 206
 207         strcpy((char *)req.inst_id, argv[3]);
 208         req.command_id = IGSCFG_CMD_RTPORT_LIST;
 209         req.oper_type = IGSCFG_OPER_TYPE_GET;
 210         req.size = sizeof(req.arg);
 211
 212         /* Send request to kernel */
 213         if (igs_cfg_request_send(&req, sizeof(igs_cfg_request_t)) < 0)
 214         {
 215                 fprintf(stderr, "Unable to send request to IGS\n");
 216                 return (FAILURE);
 217         }
 218
 219         if (req.status != IGSCFG_STATUS_SUCCESS)
 220         {
 221                 fprintf(stderr, "%s\n", req.arg);
 222                 return (FAILURE);
 223         }
 224
 225         fprintf(stdout, "Router          Interface\n");
 226
 227         list = (igs_cfg_rtport_list_t *)req.arg;
 228         for (i = 0; i < list->num_entries; i++)
 229         {
 230                 fprintf(stdout, "%08x        ", list->rtport_entry[i].mr_ip);
 231                 fprintf(stdout, "%-15s", list->rtport_entry[i].if_name);
 232         }
 233
 234         fprintf(stdout, "\n");
 235
 236         return (SUCCESS);
 237 }
 238
 239 static int
 240 igs_cfg_stats_show(char *argv[])
 241 {
 242         igs_cfg_request_t req;
 243         igs_stats_t *igss;
 244
 245         strcpy((char *)req.inst_id, argv[3]);
 246         req.command_id = IGSCFG_CMD_IGS_STATS;
 247         req.oper_type = IGSCFG_OPER_TYPE_GET;
 248         req.size = sizeof(igs_stats_t);
 249         igss = (igs_stats_t *)req.arg;
 250
 251         if (igs_cfg_request_send(&req, sizeof(igs_cfg_request_t)) < 0)
 252         {
 253                 fprintf(stderr, "Unable to send request to IGS\n");
 254                 return (FAILURE);
 255         }
 256
 257         if (req.status != IGSCFG_STATUS_SUCCESS)
 258         {
 259                 fprintf(stderr, "Unable to get the IGS stats\n");
 260                 return (FAILURE);
 261         }
 262
 263         fprintf(stdout, "IgmpPkts        IgmpQueries     "
 264                 "IgmpReports     IgmpV2Reports   IgmpLeaves\n");
 265         fprintf(stdout, "%-15d %-15d %-15d %-15d %d\n",
 266                 igss->igmp_packets, igss->igmp_queries,
 267                 igss->igmp_reports, igss->igmp_v2reports,
 268                 igss->igmp_leaves);
 269         fprintf(stdout, "IgmpNotHandled  McastGroups     "
 270                 "McastMembers    MemTimeouts\n");
 271         fprintf(stdout, "%-15d %-15d %-15d %d\n",
 272                 igss->igmp_not_handled, igss->igmp_mcast_groups,
 273                 igss->igmp_mcast_members, igss->igmp_mem_timeouts);
 274
 275         return (SUCCESS);
 276 }
 277
 278 int
 279 #if defined(linux)
 280 main(int argc, char *argv[])
 281 #else /* defined(vxworks) */
 282 #error "Unsupported osl"
 283 #endif
 284 {
 285         int j, ret;
 286         bool cmd_syntax = FALSE;
 287
 288         if (argc < 2)
 289         {
 290                 igs_usage(stdout);
 291                 return (SUCCESS);
 292         }
 293
 294         /* Find the command type */
 295         for (j = 0; j < sizeof(cmd_args)/sizeof(cmd_args[0]); j++)
 296         {
 297                 if ((strcmp(argv[1], cmd_args[j].cmd_oper_str) == 0) &&
 298                     (argc - 1 == cmd_args[j].arg_count) &&
 299                     ((cmd_args[j].cmd_id_str == NULL) ||
 300                     ((argv[2] != NULL) &&
 301                     (strcmp(argv[2], cmd_args[j].cmd_id_str) == 0))))
 302                 {
 303                         cmd_syntax = TRUE;
 304                         break;
 305                 }
 306         }
 307
 308         if (!cmd_syntax)
 309         {
 310                 igs_usage(stdout);
 311                 return (SUCCESS);
 312         }
 313
 314         /* Call the command processing function. This function parses
 315          * prepare command request and sends it kernel.
 316          */
 317         if ((ret = cmd_args[j].input(argv)) < 0)
 318         {
 319                 fprintf(stderr, "Command failed\n");
 320                 return (FAILURE);
 321         }
 322
 323         return (SUCCESS);
 324 }