l7vsd/src/snmpfunc.cpp

   1 /*!
   2  * @file  snmpfunc.cpp
   3  * @brief snmp function module.
   4  *
   5  * L7VSD: Linux Virtual Server for Layer7 Load Balancing
   6  * Copyright (C) 2010  NTT COMWARE Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  **********************************************************************/
  24 /*
  25  * Note: this file originally auto-generated by mib2c using
  26  *        : mib2c.create-dataset.conf 17337 2009-01-01 14:28:29Z magfr $
  27  *        : mib2c.scalar.conf 17337 2009-01-01 14:28:29Z magfr $
  28  *        : mib2c.notify.conf 17455 2009-04-05 09:53:29Z magfr $
  29  */
  30 #include "mibdata.h"
  31 #include "snmpagent_impl.h"
  32 #include "snmpfunc.h"
  33
  34 static const oid snmptrap_oid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
  35 netsnmp_table_data_set *vs_table;
  36 netsnmp_table_data_set *rs_table;
  37
  38
  39 /*!
  40  * initialize snmp scaler and table data set handles.
  41  *
  42  * @param[in]      error_code& is trap error code
  43  * @retrun         void
  44  */
  45 void
  46 init_snmp_handles(error_code& err)
  47 {
  48         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 76, "snmpfunc::init_snmp_handles", __FILE__, __LINE__);
  49
  50         oid       l7vsVsNumber_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 1 };
  51         oid       l7vsReplicationMode_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 4 };
  52
  53         DEBUGMSGTL(("ultramonkey_l7", "init_snmp_handles\n"));
  54
  55         int ret = netsnmp_register_scalar(netsnmp_create_handler_registration
  56                                           ("l7vsVsNumber", handle_get_vstable_count,
  57                                            l7vsVsNumber_oid,
  58                                            OID_LENGTH(l7vsVsNumber_oid),
  59                                            HANDLER_CAN_RONLY));
  60
  61         if ( ret ) {
  62                 std::string msg("netsnmp_register_scalar failed.");
  63                 Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 4, msg, __FILE__, __LINE__);
  64                 //set error code
  65                 err.setter(true, msg);
  66                 return;
  67         }
  68
  69         ret = netsnmp_register_scalar(netsnmp_create_handler_registration
  70                                       ("l7vsReplicationMode",
  71                                        handle_get_rep_state,
  72                                        l7vsReplicationMode_oid,
  73                                        OID_LENGTH(l7vsReplicationMode_oid),
  74                                        HANDLER_CAN_RONLY));
  75
  76         if (ret) {
  77                 std::string msg("netsnmp_register_scalar failed.");
  78                 Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 5, msg, __FILE__, __LINE__);
  79                 //set error code
  80                 err.setter(true, msg);
  81                 return;
  82         }
  83
  84         /*
  85          * here we initialize all the tables we're planning on supporting
  86          */
  87         initialize_virtual_service_table(err);
  88
  89         if (ret) return;
  90
  91         initialize_real_server_table(err);
  92
  93         if (ret) return;
  94 }
  95
  96 /*!
  97  * handle for virtual service count.
  98  *
  99  */
 100 int
 101 handle_get_vstable_count(netsnmp_mib_handler *handler,
 102                          netsnmp_handler_registration *reginfo,
 103                          netsnmp_agent_request_info *reqinfo,
 104                          netsnmp_request_info *requests)
 105 {
 106         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 77, "snmpfunc::handle_get_vstable_count", __FILE__, __LINE__);
 107         /*
 108          * We are never called for a GETNEXT if it's registered as a
 109          * "instance", as it's "magically" handled for us.
 110          */
 111
 112         /*
 113          * a instance handler also only hands us one request at a time, so
 114          * we don't need to loop over a list of requests; we'll only get one.
 115          */
 116
 117         switch (reqinfo->mode) {
 118
 119         case MODE_GET: {
 120                 error_code err;
 121                 //collect mibdata
 122                 l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
 123
 124                 if (err) {
 125                         std::string msg("collect mib data failed.");
 126                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 19, msg, __FILE__, __LINE__);
 127
 128                         return SNMP_ERR_GENERR;
 129                 }
 130
 131                 //get virtual serveice size
 132                 int rep_state = l7vs::mibdata::get_instance().get_vs_table_size();
 133
 134                 //set value
 135                 int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 136                                                    (u_char *)&rep_state,
 137                                                    sizeof(int));
 138
 139                 if (ret) {
 140                         std::string msg("snmp_set_var_typed_value failed.");
 141                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 20, msg, __FILE__, __LINE__);
 142
 143                         return SNMP_ERR_GENERR;
 144                 }
 145
 146                 snmpagent_impl::get_instance().increment_getrequest_count();
 147         }
 148         break;
 149         default:
 150                 /*
 151                  * we should never get here, so this is a really bad error
 152                  */
 153                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_get_vstable_count\n",
 154                          reqinfo->mode);
 155                 return SNMP_ERR_GENERR;
 156         }
 157
 158         return SNMP_ERR_NOERROR;
 159 }
 160
 161 /*!
 162  * handle for replication state.
 163  *
 164  */
 165 int
 166 handle_get_rep_state(netsnmp_mib_handler *handler,
 167                      netsnmp_handler_registration *reginfo,
 168                      netsnmp_agent_request_info *reqinfo,
 169                      netsnmp_request_info *requests)
 170 {
 171         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 78, "snmpfunc::handle_get_rep_state", __FILE__, __LINE__);
 172
 173         /*
 174          * We are never called for a GETNEXT if it's registered as a
 175          * "instance", as it's "magically" handled for us.
 176          */
 177
 178         /*
 179          * a instance handler also only hands us one request at a time, so
 180          * we don't need to loop over a list of requests; we'll only get one.
 181          */
 182
 183         switch (reqinfo->mode) {
 184
 185         case MODE_GET: {
 186                 error_code err;
 187                 //collect mibdata
 188                 l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
 189
 190                 if (err) {
 191                         std::string msg("collect mib data failed.");
 192                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 21, msg, __FILE__, __LINE__);
 193
 194                         return SNMP_ERR_GENERR;
 195                 }
 196
 197                 //get replication state
 198                 int rep_state = l7vs::mibdata::get_instance().get_replication_state();
 199
 200
 201                 //set value
 202                 int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 203                                                    (u_char *)&rep_state,
 204                                                    sizeof(int));
 205
 206                 if (ret) {
 207                         std::string msg("snmp_set_var_typed_value failed.");
 208                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 22, msg, __FILE__, __LINE__);
 209
 210                         return SNMP_ERR_GENERR;
 211                 }
 212
 213                 snmpagent_impl::get_instance().increment_getrequest_count();
 214         }
 215         break;
 216         default:
 217                 /*
 218                  * we should never get here, so this is a really bad error
 219                  */
 220                 snmp_log(LOG_ERR,
 221                          "unknown mode (%d) in handle_get_rep_state\n",
 222                          reqinfo->mode);
 223                 return SNMP_ERR_GENERR;
 224         }
 225
 226         return SNMP_ERR_NOERROR;
 227 }
 228
 229 /*!
 230  * initialize virtual service table data set.
 231  *
 232  * @param[in]      error_code& is trap error code
 233  * @retrun         void
 234  */
 235 void
 236 initialize_virtual_service_table(error_code &err)
 237 {
 238         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 79, "snmpfunc::initialize_virtual_service_table", __FILE__, __LINE__);
 239
 240         oid       l7vsVsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 2 };
 241
 242         /*
 243          * create the table structure itself
 244          */
 245         vs_table = netsnmp_create_table_data_set("l7vsVsTable");
 246
 247         if (!vs_table) {
 248                 std::string msg("netsnmp create l7vsVsTable data set failed.");
 249                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 23, msg, __FILE__, __LINE__);
 250                 //set error code
 251                 err.setter(true, msg);
 252                 return;
 253         }
 254
 255         //set data set into mibdata
 256         mibdata::get_instance().set_vs_table(vs_table);
 257
 258         /*
 259          * comment this out or delete if you don't support creation of new rows
 260          */
 261         vs_table->allow_creation = 1;
 262
 263         /***************************************************
 264          * Adding indexes
 265          */
 266         DEBUGMSGTL(("initialize_virtual_service_table",
 267                     "adding indexes to table l7vsVsTable\n"));
 268         netsnmp_table_set_add_indexes(vs_table, ASN_INTEGER,       /* index: l7vsVsIndex */
 269                                       0);
 270
 271         DEBUGMSGTL(("initialize_virtual_service_table",
 272                     "adding column types to table l7vsVsTable\n"));
 273         netsnmp_table_set_multi_add_default_row(vs_table,
 274                                                 COLUMN_L7VSVSINDEX,
 275                                                 ASN_INTEGER, 0, NULL, 0,
 276                                                 COLUMN_L7VSVSPROTOCOL,
 277                                                 ASN_INTEGER, 0, NULL, 0,
 278                                                 COLUMN_L7VSVSADDRTYPE,
 279                                                 ASN_INTEGER, 0, NULL, 0,
 280                                                 COLUMN_L7VSVSADDR,
 281                                                 ASN_OCTET_STR, 0, NULL, 0,
 282                                                 COLUMN_L7VSVSPORT,
 283                                                 ASN_UNSIGNED, 0, NULL, 0,
 284                                                 COLUMN_L7VSVSPROTOCOLMODULENAME,
 285                                                 ASN_OCTET_STR, 0, NULL, 0,
 286                                                 COLUMN_L7VSVSPROTOCOLMODULEOPTIONS,
 287                                                 ASN_OCTET_STR, 0, NULL, 0,
 288                                                 COLUMN_L7VSVSSCHEDULEMODULENAME,
 289                                                 ASN_OCTET_STR, 0, NULL, 0,
 290                                                 COLUMN_L7VSVSSCHEDULEMODULEOPTIONS,
 291                                                 ASN_OCTET_STR, 0, NULL, 0,
 292                                                 COLUMN_L7VSVSSORRYADDRTYPE,
 293                                                 ASN_INTEGER, 0, NULL, 0,
 294                                                 COLUMN_L7VSVSSORRYADDR,
 295                                                 ASN_OCTET_STR, 0, NULL, 0,
 296                                                 COLUMN_L7VSVSSORRYPORT,
 297                                                 ASN_UNSIGNED, 0, NULL, 0,
 298                                                 COLUMN_L7VSVSSORRYCONNLIMIT,
 299                                                 ASN_COUNTER64, 0, NULL, 0,
 300                                                 COLUMN_L7VSVSSORRYFORCEENABLED,
 301                                                 ASN_INTEGER, 0, NULL, 0,
 302                                                 COLUMN_L7VSVSTHROUGHPUTUP,
 303                                                 ASN_COUNTER64, 0, NULL, 0,
 304                                                 COLUMN_L7VSVSTHROUGHPUTDOWN,
 305                                                 ASN_COUNTER64, 0, NULL, 0,
 306                                                 COLUMN_L7VSVSTHROUGHPUTUPQOS,
 307                                                 ASN_COUNTER64, 0, NULL, 0,
 308                                                 COLUMN_L7VSVSTHROUGHPUTDOWNQOS,
 309                                                 ASN_COUNTER64, 0, NULL, 0,
 310                                                 COLUMN_L7VSVSSSLFLAG,
 311                                                 ASN_INTEGER, 0, NULL, 0,
 312                                                 COLUMN_L7VSVSSESSIONPOOLCOUNT,
 313                                                 ASN_INTEGER, 0, NULL, 0,
 314                                                 COLUMN_L7VSVSSESSIONACTIVECOUNT,
 315                                                 ASN_INTEGER, 0, NULL, 0,
 316                                                 COLUMN_L7VSVSSESSIONWAITCOUNT,
 317                                                 ASN_INTEGER, 0, NULL, 0,
 318                                                 COLUMN_L7VSVSHTTPTOTALCOUNT,
 319                                                 ASN_COUNTER64, 0, NULL, 0,
 320                                                 COLUMN_L7VSVSHTTPGETCOUNT,
 321                                                 ASN_COUNTER64, 0, NULL, 0,
 322                                                 COLUMN_L7VSVSHTTPPOSTCOUNT,
 323                                                 ASN_COUNTER64, 0, NULL, 0,
 324                                                 COLUMN_L7VSVSRSNUMBER,
 325                                                 ASN_INTEGER, 0, NULL, 0, 0);
 326
 327         /*
 328          * registering the table with the master agent
 329          */
 330         /*
 331          * note: if you don't need a subhandler to deal with any aspects
 332          * of the request, change handle_get_vstable to "NULL"
 333          */
 334         int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration
 335                         ("l7vsVsTable", handle_get_vstable,
 336                          l7vsVsTable_oid,
 337                          OID_LENGTH(l7vsVsTable_oid),
 338                          HANDLER_CAN_RWRITE), vs_table, NULL);
 339
 340         if (ret) {
 341                 std::string msg("netsnmp create l7vsVsTable data set failed.");
 342                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 24, msg, __FILE__, __LINE__);
 343                 //set error code
 344                 err.setter(true, msg);
 345                 return;
 346         }
 347 }
 348
 349 /*!
 350  * initialize real server table data set.
 351  *
 352  * @param[in]      error_code& is trap error code
 353  * @retrun         void
 354  */
 355 void
 356 initialize_real_server_table(error_code &err)
 357 {
 358         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 80, "snmpfunc::initialize_real_server_table", __FILE__, __LINE__);
 359
 360         oid       l7vsRsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 3 };
 361
 362         /*
 363          * create the table structure itself
 364          */
 365         rs_table = netsnmp_create_table_data_set("l7vsRsTable");
 366
 367         if (!rs_table) {
 368                 std::string msg("netsnmp create l7vsRsTable data set failed.");
 369                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 25, msg, __FILE__, __LINE__);
 370                 //set error code
 371                 err.setter(true, msg);
 372                 return;
 373         }
 374
 375         //set data set into mibdata
 376         mibdata::get_instance().set_rs_table(rs_table);
 377         /*
 378          * comment this out or delete if you don't support creation of new rows
 379          */
 380         rs_table->allow_creation = 1;
 381
 382         /***************************************************
 383          * Adding indexes
 384          */
 385         DEBUGMSGTL(("initialize_real_server_table",
 386                     "adding indexes to table l7vsRsTable\n"));
 387         netsnmp_table_set_add_indexes(rs_table, ASN_INTEGER,       /* index: l7vsRsIndex */
 388                                       0);
 389
 390         DEBUGMSGTL(("initialize_real_server_table",
 391                     "adding column types to table l7vsRsTable\n"));
 392         netsnmp_table_set_multi_add_default_row(rs_table,
 393                                                 COLUMN_L7VSRSINDEX,
 394                                                 ASN_INTEGER, 0, NULL, 0,
 395                                                 COLUMN_L7VSRSVSINDEX,
 396                                                 ASN_INTEGER, 0, NULL, 0,
 397                                                 COLUMN_L7VSRSADDRTYPE,
 398                                                 ASN_INTEGER, 0, NULL, 0,
 399                                                 COLUMN_L7VSRSADDR,
 400                                                 ASN_OCTET_STR, 0, NULL, 0,
 401                                                 COLUMN_L7VSRSPORT,
 402                                                 ASN_UNSIGNED, 0, NULL, 0,
 403                                                 COLUMN_L7VSRSFORWARD,
 404                                                 ASN_INTEGER, 0, NULL, 0,
 405                                                 COLUMN_L7VSRSWEIGHT,
 406                                                 ASN_INTEGER, 0, NULL, 0,
 407                                                 COLUMN_L7VSRSACTIVECONN,
 408                                                 ASN_INTEGER, 0, NULL, 0,
 409                                                 COLUMN_L7VSRSINACTIVECONN,
 410                                                 ASN_INTEGER, 0, NULL, 0, 0);
 411
 412         /*
 413          * registering the table with the master agent
 414          */
 415         /*
 416          * note: if you don't need a subhandler to deal with any aspects
 417          * of the request, change handle_get_rstable to "NULL"
 418          */
 419         int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration
 420                         ("l7vsRsTable", handle_get_rstable,
 421                          l7vsRsTable_oid,
 422                          OID_LENGTH(l7vsRsTable_oid),
 423                          HANDLER_CAN_RWRITE), rs_table, NULL);
 424
 425         if (ret) {
 426                 std::string msg("netsnmp create l7vsRsTable data set failed.");
 427                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 26, msg, __FILE__, __LINE__);
 428                 //set error code
 429                 err.setter(true, msg);
 430                 return;
 431         }
 432
 433 }
 434
 435 /*!
 436  * handle for virtual service table.
 437  *
 438  */
 439 int
 440 handle_get_vstable(netsnmp_mib_handler *handler,
 441                    netsnmp_handler_registration *reginfo,
 442                    netsnmp_agent_request_info *reqinfo,
 443                    netsnmp_request_info *requests)
 444 {
 445         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 81, "snmpfunc::handle_get_vstable", __FILE__, __LINE__);
 446
 447         /*
 448          * perform anything here that you need to do.  The requests have
 449          * already been processed by the master table_dataset handler, but
 450          * this gives you chance to act on the request in some other way
 451          * if need be.
 452          */
 453         error_code err;
 454         //collect mibdata
 455         l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
 456
 457         if (err) {
 458                 std::string msg("collect mib data failed.");
 459                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 27, msg, __FILE__, __LINE__);
 460
 461                 return SNMP_ERR_GENERR;
 462         }
 463
 464         snmpagent_impl::get_instance().increment_getrequest_count();
 465
 466         return SNMP_ERR_NOERROR;
 467 }
 468
 469 /*!
 470  * handle for real server table.
 471  *
 472  */
 473 int
 474 handle_get_rstable(netsnmp_mib_handler *handler,
 475                    netsnmp_handler_registration *reginfo,
 476                    netsnmp_agent_request_info *reqinfo,
 477                    netsnmp_request_info *requests)
 478 {
 479         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 82, "snmpfunc::handle_get_rstable", __FILE__, __LINE__);
 480
 481         /*
 482          * perform anything here that you need to do.  The requests have
 483          * already been processed by the master table_dataset handler, but
 484          * this gives you chance to act on the request in some other way
 485          * if need be.
 486          */
 487         error_code err;
 488         //collect mibdata
 489         l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
 490
 491         if (err) {
 492                 std::string msg("collect mib data failed.");
 493                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 28, msg, __FILE__, __LINE__);
 494
 495                 return SNMP_ERR_GENERR;
 496         }
 497
 498         snmpagent_impl::get_instance().increment_getrequest_count();
 499
 500         return SNMP_ERR_NOERROR;
 501 }
 502
 503 /*!
 504  * send service start trap.
 505  *
 506  * @param[in]      std::string is trap message
 507  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 508  */
 509 int
 510 trap_service_start(const std::string &in_trapmessage)
 511 {
 512         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 83, "snmpfunc::trap_service_start", __FILE__, __LINE__);
 513
 514         /*-------- DEBUG LOG --------*/
 515         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 516                 std::stringstream    debugstr;
 517                 debugstr << "snmpfunc::trap_service_start arguments:";
 518                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 519                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 84, debugstr.str(), __FILE__, __LINE__);
 520         }
 521         /*------ DEBUG LOG END ------*/
 522
 523         netsnmp_variable_list *var_list = NULL;
 524         netsnmp_variable_list *ret_list = NULL;
 525         oid       l7vsServiceStart_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 1 };
 526
 527         /*
 528          * Set the snmpTrapOid.0 value
 529          */
 530         ret_list = snmp_varlist_add_variable(&var_list,
 531                                              snmptrap_oid,
 532                                              OID_LENGTH(snmptrap_oid),
 533                                              ASN_OBJECT_ID,
 534                                              (u_char*)l7vsServiceStart_oid,
 535                                              sizeof(l7vsServiceStart_oid));
 536         if (!ret_list) {
 537                 std::string msg("snmp_varlist_add_variable failed.");
 538                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 29, msg, __FILE__, __LINE__);
 539                 return SNMP_ERR_GENERR;
 540         }
 541
 542         ret_list = snmp_varlist_add_variable(&var_list,
 543                                              l7vsServiceStart_oid,
 544                                              OID_LENGTH(l7vsServiceStart_oid),
 545                                              ASN_OCTET_STR,
 546                                              (u_char*)in_trapmessage.c_str(),
 547                                              in_trapmessage.length());
 548         if (!ret_list) {
 549                 std::string msg("snmp_varlist_add_variable failed.");
 550                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 30, msg, __FILE__, __LINE__);
 551                 return SNMP_ERR_GENERR;
 552         }
 553         /*
 554          * Send the trap to the list of configured destinations
 555          *  and clean up
 556          */
 557         send_v2trap(var_list);
 558         snmp_free_varbind(var_list);
 559
 560         return SNMP_ERR_NOERROR;
 561 }
 562
 563 /*!
 564  * send service stop trap.
 565  *
 566  * @param[in]      std::string is trap message
 567  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 568  */
 569 int
 570 trap_service_stop(const std::string &in_trapmessage)
 571 {
 572         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 85, "snmpfunc::trap_service_stop", __FILE__, __LINE__);
 573
 574         /*-------- DEBUG LOG --------*/
 575         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 576                 std::stringstream    debugstr;
 577                 debugstr << "snmpfunc::trap_service_stop arguments:";
 578                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 579                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 86, debugstr.str(), __FILE__, __LINE__);
 580         }
 581         /*------ DEBUG LOG END ------*/
 582
 583         netsnmp_variable_list *var_list = NULL;
 584         netsnmp_variable_list *ret_list = NULL;
 585         oid       l7vsServiceStop_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 2 };
 586
 587         /*
 588          * Set the snmpTrapOid.0 value
 589          */
 590         ret_list = snmp_varlist_add_variable(&var_list,
 591                                              snmptrap_oid,
 592                                              OID_LENGTH(snmptrap_oid),
 593                                              ASN_OBJECT_ID,
 594                                              (u_char*)l7vsServiceStop_oid,
 595                                              sizeof(l7vsServiceStop_oid));
 596         if (!ret_list) {
 597                 std::string msg("snmp_varlist_add_variable failed.");
 598                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 31, msg, __FILE__, __LINE__);
 599                 return SNMP_ERR_GENERR;
 600         }
 601
 602         ret_list = snmp_varlist_add_variable(&var_list,
 603                                              l7vsServiceStop_oid,
 604                                              OID_LENGTH(l7vsServiceStop_oid),
 605                                              ASN_OCTET_STR,
 606                                              (u_char*)in_trapmessage.c_str(),
 607                                              in_trapmessage.length());
 608         if (!ret_list) {
 609                 std::string msg("snmp_varlist_add_variable failed.");
 610                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 32, msg, __FILE__, __LINE__);
 611                 return SNMP_ERR_GENERR;
 612         }
 613         /*
 614          * Send the trap to the list of configured destinations
 615          *  and clean up
 616          */
 617         send_v2trap(var_list);
 618         snmp_free_varbind(var_list);
 619
 620         return SNMP_ERR_NOERROR;
 621 }
 622
 623 /*!
 624  * send virtual service add trap.
 625  *
 626  * @param[in]      std::string is trap message
 627  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 628  */
 629 int
 630 trap_vs_add(const std::string &in_trapmessage)
 631 {
 632         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 87, "snmpfunc::trap_vs_add", __FILE__, __LINE__);
 633
 634         /*-------- DEBUG LOG --------*/
 635         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 636                 std::stringstream    debugstr;
 637                 debugstr << "snmpfunc::trap_vs_add arguments:";
 638                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 639                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 88, debugstr.str(), __FILE__, __LINE__);
 640         }
 641         /*------ DEBUG LOG END ------*/
 642
 643         netsnmp_variable_list *var_list = NULL;
 644         netsnmp_variable_list *ret_list = NULL;
 645         oid       l7vsBalancingVsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 1 };
 646
 647
 648         /*
 649          * Set the snmpTrapOid.0 value
 650          */
 651         ret_list = snmp_varlist_add_variable(&var_list,
 652                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 653                                              ASN_OBJECT_ID,
 654                                              (u_char*)l7vsBalancingVsAdd_oid,
 655                                              sizeof(l7vsBalancingVsAdd_oid));
 656         if (!ret_list) {
 657                 std::string msg("snmp_varlist_add_variable failed.");
 658                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 33, msg, __FILE__, __LINE__);
 659                 return SNMP_ERR_GENERR;
 660         }
 661
 662         ret_list = snmp_varlist_add_variable(&var_list,
 663                                              l7vsBalancingVsAdd_oid,
 664                                              OID_LENGTH(l7vsBalancingVsAdd_oid),
 665                                              ASN_OCTET_STR,
 666                                              (u_char*)in_trapmessage.c_str(),
 667                                              in_trapmessage.length());
 668         if (!ret_list) {
 669                 std::string msg("snmp_varlist_add_variable failed.");
 670                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 34, msg, __FILE__, __LINE__);
 671                 return SNMP_ERR_GENERR;
 672         }
 673         /*
 674          * Add any extra (optional) objects here
 675          */
 676
 677         /*
 678          * Send the trap to the list of configured destinations
 679          *  and clean up
 680          */
 681         send_v2trap(var_list);
 682         snmp_free_varbind(var_list);
 683
 684         return SNMP_ERR_NOERROR;
 685 }
 686
 687 /*!
 688  * send virtual service change trap.
 689  *
 690  * @param[in]      std::string is trap message
 691  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 692  */
 693 int
 694 trap_vs_change(const std::string &in_trapmessage)
 695 {
 696         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 89, "snmpfunc::trap_vs_change", __FILE__, __LINE__);
 697
 698         /*-------- DEBUG LOG --------*/
 699         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 700                 std::stringstream    debugstr;
 701                 debugstr << "snmpfunc::trap_vs_change arguments:";
 702                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 703                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 90, debugstr.str(), __FILE__, __LINE__);
 704         }
 705         /*------ DEBUG LOG END ------*/
 706
 707         netsnmp_variable_list *var_list = NULL;
 708         netsnmp_variable_list *ret_list = NULL;
 709         oid       l7vsBalancingVsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 2 };
 710
 711         /*
 712          * Set the snmpTrapOid.0 value
 713          */
 714         ret_list = snmp_varlist_add_variable(&var_list,
 715                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 716                                              ASN_OBJECT_ID,
 717                                              (u_char*)l7vsBalancingVsChange_oid,
 718                                              sizeof(l7vsBalancingVsChange_oid));
 719         if (!ret_list) {
 720                 std::string msg("snmp_varlist_add_variable failed.");
 721                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 35, msg, __FILE__, __LINE__);
 722                 return SNMP_ERR_GENERR;
 723         }
 724
 725         ret_list = snmp_varlist_add_variable(&var_list,
 726                                              l7vsBalancingVsChange_oid,
 727                                              OID_LENGTH(l7vsBalancingVsChange_oid),
 728                                              ASN_OCTET_STR,
 729                                              (u_char*)in_trapmessage.c_str(),
 730                                              in_trapmessage.length());
 731         if (!ret_list) {
 732                 std::string msg("snmp_varlist_add_variable failed.");
 733                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 36, msg, __FILE__, __LINE__);
 734                 return SNMP_ERR_GENERR;
 735         }
 736         /*
 737          * Add any extra (optional) objects here
 738          */
 739
 740         /*
 741          * Send the trap to the list of configured destinations
 742          *  and clean up
 743          */
 744         send_v2trap(var_list);
 745         snmp_free_varbind(var_list);
 746
 747         return SNMP_ERR_NOERROR;
 748 }
 749
 750 /*!
 751  * send virtual service remove trap.
 752  *
 753  * @param[in]      std::string is trap message
 754  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 755  */
 756 int
 757 trap_vs_remove(const std::string &in_trapmessage)
 758 {
 759         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 91, "snmpfunc::trap_vs_remove", __FILE__, __LINE__);
 760
 761         /*-------- DEBUG LOG --------*/
 762         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 763                 std::stringstream    debugstr;
 764                 debugstr << "snmpfunc::trap_vs_remove arguments:";
 765                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 766                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 92, debugstr.str(), __FILE__, __LINE__);
 767         }
 768         /*------ DEBUG LOG END ------*/
 769
 770         netsnmp_variable_list *var_list = NULL;
 771         netsnmp_variable_list *ret_list = NULL;
 772         oid       l7vsBalancingVsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 3 };
 773
 774         /*
 775          * Set the snmpTrapOid.0 value
 776          */
 777         ret_list = snmp_varlist_add_variable(&var_list,
 778                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 779                                              ASN_OBJECT_ID,
 780                                              (u_char*)l7vsBalancingVsRemove_oid,
 781                                              sizeof(l7vsBalancingVsRemove_oid));
 782         if (!ret_list) {
 783                 std::string msg("snmp_varlist_add_variable failed.");
 784                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 37, msg, __FILE__, __LINE__);
 785                 return SNMP_ERR_GENERR;
 786         }
 787
 788         ret_list = snmp_varlist_add_variable(&var_list,
 789                                              l7vsBalancingVsRemove_oid,
 790                                              OID_LENGTH(l7vsBalancingVsRemove_oid),
 791                                              ASN_OCTET_STR,
 792                                              (u_char*)in_trapmessage.c_str(),
 793                                              in_trapmessage.length());
 794         if (!ret_list) {
 795                 std::string msg("snmp_varlist_add_variable failed.");
 796                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 38, msg, __FILE__, __LINE__);
 797                 return SNMP_ERR_GENERR;
 798         }
 799         /*
 800          * Add any extra (optional) objects here
 801          */
 802
 803         /*
 804          * Send the trap to the list of configured destinations
 805          *  and clean up
 806          */
 807         send_v2trap(var_list);
 808         snmp_free_varbind(var_list);
 809
 810         return SNMP_ERR_NOERROR;
 811 }
 812
 813 /*!
 814  * send real server add trap.
 815  *
 816  * @param[in]      std::string is trap message
 817  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 818  */
 819 int
 820 trap_rs_add(const std::string &in_trapmessage)
 821 {
 822         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 93, "snmpfunc::trap_rs_add", __FILE__, __LINE__);
 823
 824         /*-------- DEBUG LOG --------*/
 825         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 826                 std::stringstream    debugstr;
 827                 debugstr << "snmpfunc::trap_rs_add arguments:";
 828                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 829                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 94, debugstr.str(), __FILE__, __LINE__);
 830         }
 831         /*------ DEBUG LOG END ------*/
 832
 833         netsnmp_variable_list *var_list = NULL;
 834         netsnmp_variable_list *ret_list = NULL;
 835         oid       l7vsBalancingRsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 4 };
 836
 837         /*
 838          * Set the snmpTrapOid.0 value
 839          */
 840         ret_list = snmp_varlist_add_variable(&var_list,
 841                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 842                                              ASN_OBJECT_ID,
 843                                              (u_char*)l7vsBalancingRsAdd_oid,
 844                                              sizeof(l7vsBalancingRsAdd_oid));
 845         if (!ret_list) {
 846                 std::string msg("snmp_varlist_add_variable failed.");
 847                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 39, msg, __FILE__, __LINE__);
 848                 return SNMP_ERR_GENERR;
 849         }
 850
 851         ret_list = snmp_varlist_add_variable(&var_list,
 852                                              l7vsBalancingRsAdd_oid,
 853                                              OID_LENGTH(l7vsBalancingRsAdd_oid),
 854                                              ASN_OCTET_STR,
 855                                              (u_char*)in_trapmessage.c_str(),
 856                                              in_trapmessage.length());
 857         if (!ret_list) {
 858                 std::string msg("snmp_varlist_add_variable failed.");
 859                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 40, msg, __FILE__, __LINE__);
 860                 return SNMP_ERR_GENERR;
 861         }
 862         /*
 863          * Add any extra (optional) objects here
 864          */
 865
 866         /*
 867          * Send the trap to the list of configured destinations
 868          *  and clean up
 869          */
 870         send_v2trap(var_list);
 871         snmp_free_varbind(var_list);
 872
 873         return SNMP_ERR_NOERROR;
 874 }
 875
 876 /*!
 877  * send real server change trap.
 878  *
 879  * @param[in]      std::string is trap message
 880  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 881  */
 882 int
 883 trap_rs_change(const std::string &in_trapmessage)
 884 {
 885         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 95, "snmpfunc::trap_rs_change", __FILE__, __LINE__);
 886
 887         /*-------- DEBUG LOG --------*/
 888         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 889                 std::stringstream    debugstr;
 890                 debugstr << "snmpfunc::trap_rs_change arguments:";
 891                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 892                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 96, debugstr.str(), __FILE__, __LINE__);
 893         }
 894         /*------ DEBUG LOG END ------*/
 895
 896         netsnmp_variable_list *var_list = NULL;
 897         netsnmp_variable_list *ret_list = NULL;
 898         oid       l7vsBalancingRsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 5 };
 899
 900         /*
 901          * Set the snmpTrapOid.0 value
 902          */
 903         ret_list = snmp_varlist_add_variable(&var_list,
 904                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 905                                              ASN_OBJECT_ID,
 906                                              (u_char*)l7vsBalancingRsChange_oid,
 907                                              sizeof(l7vsBalancingRsChange_oid));
 908         if (!ret_list) {
 909                 std::string msg("snmp_varlist_add_variable failed.");
 910                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 41, msg, __FILE__, __LINE__);
 911                 return SNMP_ERR_GENERR;
 912         }
 913
 914         ret_list = snmp_varlist_add_variable(&var_list,
 915                                              l7vsBalancingRsChange_oid,
 916                                              OID_LENGTH(l7vsBalancingRsChange_oid),
 917                                              ASN_OCTET_STR,
 918                                              (u_char*)in_trapmessage.c_str(),
 919                                              in_trapmessage.length());
 920         if (!ret_list) {
 921                 std::string msg("snmp_varlist_add_variable failed.");
 922                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 42, msg, __FILE__, __LINE__);
 923                 return SNMP_ERR_GENERR;
 924         }
 925         /*
 926          * Add any extra (optional) objects here
 927          */
 928
 929         /*
 930          * Send the trap to the list of configured destinations
 931          *  and clean up
 932          */
 933         send_v2trap(var_list);
 934         snmp_free_varbind(var_list);
 935
 936         return SNMP_ERR_NOERROR;
 937 }
 938
 939 /*!
 940  * send real server remove trap.
 941  *
 942  * @param[in]      std::string is trap message
 943  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
 944  */
 945 int
 946 trap_rs_remove(const std::string &in_trapmessage)
 947 {
 948         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 97, "snmpfunc::trap_rs_remove", __FILE__, __LINE__);
 949
 950         /*-------- DEBUG LOG --------*/
 951         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 952                 std::stringstream    debugstr;
 953                 debugstr << "snmpfunc::trap_rs_remove arguments:";
 954                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
 955                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 98, debugstr.str(), __FILE__, __LINE__);
 956         }
 957         /*------ DEBUG LOG END ------*/
 958
 959         netsnmp_variable_list *var_list = NULL;
 960         netsnmp_variable_list *ret_list = NULL;
 961         oid       l7vsBalancingRsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 6 };
 962         /*
 963          * Set the snmpTrapOid.0 value
 964          */
 965         ret_list = snmp_varlist_add_variable(&var_list,
 966                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
 967                                              ASN_OBJECT_ID,
 968                                              (u_char*)l7vsBalancingRsRemove_oid,
 969                                              sizeof(l7vsBalancingRsRemove_oid));
 970         if (!ret_list) {
 971                 std::string msg("snmp_varlist_add_variable failed.");
 972                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 43, msg, __FILE__, __LINE__);
 973                 return SNMP_ERR_GENERR;
 974         }
 975
 976         ret_list = snmp_varlist_add_variable(&var_list,
 977                                              l7vsBalancingRsRemove_oid,
 978                                              OID_LENGTH(l7vsBalancingRsRemove_oid),
 979                                              ASN_OCTET_STR,
 980                                              (u_char*)in_trapmessage.c_str(),
 981                                              in_trapmessage.length());
 982         if (!ret_list) {
 983                 std::string msg("snmp_varlist_add_variable failed.");
 984                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 44, msg, __FILE__, __LINE__);
 985                 return SNMP_ERR_GENERR;
 986         }
 987         /*
 988          * Add any extra (optional) objects here
 989          */
 990
 991         /*
 992          * Send the trap to the list of configured destinations
 993          *  and clean up
 994          */
 995         send_v2trap(var_list);
 996         snmp_free_varbind(var_list);
 997
 998         return SNMP_ERR_NOERROR;
 999 }
1000
1001 /*!
1002  * send upstream QoS alert on trap.
1003  *
1004  * @param[in]      std::string is trap message
1005  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1006  */
1007 int
1008 trap_up_qos_alert_on(const std::string &in_trapmessage)
1009 {
1010         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 99, "snmpfunc::trap_up_qos_alert_on", __FILE__, __LINE__);
1011
1012         /*-------- DEBUG LOG --------*/
1013         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1014                 std::stringstream    debugstr;
1015                 debugstr << "snmpfunc::trap_up_qos_alert_on arguments:";
1016                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1017                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 100, debugstr.str(), __FILE__, __LINE__);
1018         }
1019         /*------ DEBUG LOG END ------*/
1020
1021         netsnmp_variable_list *var_list = NULL;
1022         netsnmp_variable_list *ret_list = NULL;
1023         oid       l7vsBalancingUpQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 7 };
1024
1025         /*
1026          * Set the snmpTrapOid.0 value
1027          */
1028         ret_list = snmp_varlist_add_variable(&var_list,
1029                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1030                                              ASN_OBJECT_ID,
1031                                              (u_char*)l7vsBalancingUpQoSAlertOn_oid,
1032                                              sizeof(l7vsBalancingUpQoSAlertOn_oid));
1033         if (!ret_list) {
1034                 std::string msg("snmp_varlist_add_variable failed.");
1035                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 45, msg, __FILE__, __LINE__);
1036                 return SNMP_ERR_GENERR;
1037         }
1038
1039         ret_list = snmp_varlist_add_variable(&var_list,
1040                                              l7vsBalancingUpQoSAlertOn_oid,
1041                                              OID_LENGTH(l7vsBalancingUpQoSAlertOn_oid),
1042                                              ASN_OCTET_STR,
1043                                              (u_char*)in_trapmessage.c_str(),
1044                                              in_trapmessage.length());
1045         if (!ret_list) {
1046                 std::string msg("snmp_varlist_add_variable failed.");
1047                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 46, msg, __FILE__, __LINE__);
1048                 return SNMP_ERR_GENERR;
1049         }
1050         /*
1051          * Add any extra (optional) objects here
1052          */
1053
1054         /*
1055          * Send the trap to the list of configured destinations
1056          *  and clean up
1057          */
1058         send_v2trap(var_list);
1059         snmp_free_varbind(var_list);
1060
1061         return SNMP_ERR_NOERROR;
1062 }
1063
1064 /*!
1065  * send upstream QoS alert off trap.
1066  *
1067  * @param[in]      std::string is trap message
1068  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1069  */
1070 int
1071 trap_up_qos_alert_off(const std::string &in_trapmessage)
1072 {
1073         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 101, "snmpfunc::trap_up_qos_alert_off", __FILE__, __LINE__);
1074
1075         /*-------- DEBUG LOG --------*/
1076         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1077                 std::stringstream    debugstr;
1078                 debugstr << "snmpfunc::trap_up_qos_alert_off arguments:";
1079                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1080                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 102, debugstr.str(), __FILE__, __LINE__);
1081         }
1082         /*------ DEBUG LOG END ------*/
1083
1084         netsnmp_variable_list *var_list = NULL;
1085         netsnmp_variable_list *ret_list = NULL;
1086         oid       l7vsBalancingUpQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 8 };
1087
1088         /*
1089          * Set the snmpTrapOid.0 value
1090          */
1091         ret_list = snmp_varlist_add_variable(&var_list,
1092                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1093                                              ASN_OBJECT_ID,
1094                                              (u_char*)l7vsBalancingUpQoSAlertOff_oid,
1095                                              sizeof(l7vsBalancingUpQoSAlertOff_oid));
1096         if (!ret_list) {
1097                 std::string msg("snmp_varlist_add_variable failed.");
1098                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 47, msg, __FILE__, __LINE__);
1099                 return SNMP_ERR_GENERR;
1100         }
1101
1102         ret_list = snmp_varlist_add_variable(&var_list,
1103                                              l7vsBalancingUpQoSAlertOff_oid,
1104                                              OID_LENGTH(l7vsBalancingUpQoSAlertOff_oid),
1105                                              ASN_OCTET_STR,
1106                                              (u_char*)in_trapmessage.c_str(),
1107                                              in_trapmessage.length());
1108         if (!ret_list) {
1109                 std::string msg("snmp_varlist_add_variable failed.");
1110                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 48, msg, __FILE__, __LINE__);
1111                 return SNMP_ERR_GENERR;
1112         }
1113         /*
1114          * Add any extra (optional) objects here
1115          */
1116
1117         /*
1118          * Send the trap to the list of configured destinations
1119          *  and clean up
1120          */
1121         send_v2trap(var_list);
1122         snmp_free_varbind(var_list);
1123
1124         return SNMP_ERR_NOERROR;
1125 }
1126
1127 /*!
1128  * send downstream QoS alert on trap.
1129  *
1130  * @param[in]      std::string is trap message
1131  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1132  */
1133 int
1134 trap_down_qos_alert_on(const std::string &in_trapmessage)
1135 {
1136         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 103, "snmpfunc::trap_down_qos_alert_on", __FILE__, __LINE__);
1137
1138         /*-------- DEBUG LOG --------*/
1139         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1140                 std::stringstream    debugstr;
1141                 debugstr << "snmpfunc::trap_down_qos_alert_on arguments:";
1142                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1143                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 104, debugstr.str(), __FILE__, __LINE__);
1144         }
1145         /*------ DEBUG LOG END ------*/
1146
1147         netsnmp_variable_list *var_list = NULL;
1148         netsnmp_variable_list *ret_list = NULL;
1149         oid       l7vsBalancingDownQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 9 };
1150
1151         /*
1152          * Set the snmpTrapOid.0 value
1153          */
1154         ret_list = snmp_varlist_add_variable(&var_list,
1155                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1156                                              ASN_OBJECT_ID,
1157                                              (u_char*)l7vsBalancingDownQoSAlertOn_oid,
1158                                              sizeof(l7vsBalancingDownQoSAlertOn_oid));
1159         if (!ret_list) {
1160                 std::string msg("snmp_varlist_add_variable failed.");
1161                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 49, msg, __FILE__, __LINE__);
1162                 return SNMP_ERR_GENERR;
1163         }
1164
1165         ret_list = snmp_varlist_add_variable(&var_list,
1166                                              l7vsBalancingDownQoSAlertOn_oid,
1167                                              OID_LENGTH(l7vsBalancingDownQoSAlertOn_oid),
1168                                              ASN_OCTET_STR,
1169                                              (u_char*)in_trapmessage.c_str(),
1170                                              in_trapmessage.length());
1171         if (!ret_list) {
1172                 std::string msg("snmp_varlist_add_variable failed.");
1173                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 50, msg, __FILE__, __LINE__);
1174                 return SNMP_ERR_GENERR;
1175         }
1176         /*
1177          * Add any extra (optional) objects here
1178          */
1179
1180         /*
1181          * Send the trap to the list of configured destinations
1182          *  and clean up
1183          */
1184         send_v2trap(var_list);
1185         snmp_free_varbind(var_list);
1186
1187         return SNMP_ERR_NOERROR;
1188 }
1189
1190 /*!
1191  * send downstream QoS alert off trap.
1192  *
1193  * @param[in]      std::string is trap message
1194  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1195  */
1196 int
1197 trap_down_qos_alert_off(const std::string &in_trapmessage)
1198 {
1199         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 105, "snmpfunc::trap_down_qos_alert_off", __FILE__, __LINE__);
1200
1201         /*-------- DEBUG LOG --------*/
1202         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1203                 std::stringstream    debugstr;
1204                 debugstr << "snmpfunc::trap_down_qos_alert_off arguments:";
1205                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1206                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 106, debugstr.str(), __FILE__, __LINE__);
1207         }
1208         /*------ DEBUG LOG END ------*/
1209
1210         netsnmp_variable_list *var_list = NULL;
1211         netsnmp_variable_list *ret_list = NULL;
1212         oid       l7vsBalancingDownQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 10 };
1213
1214         /*
1215          * Set the snmpTrapOid.0 value
1216          */
1217         ret_list = snmp_varlist_add_variable(&var_list,
1218                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1219                                              ASN_OBJECT_ID,
1220                                              (u_char*)l7vsBalancingDownQoSAlertOff_oid,
1221                                              sizeof(l7vsBalancingDownQoSAlertOff_oid));
1222         if (!ret_list) {
1223                 std::string msg("snmp_varlist_add_variable failed.");
1224                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 51, msg, __FILE__, __LINE__);
1225                 return SNMP_ERR_GENERR;
1226         }
1227
1228         ret_list = snmp_varlist_add_variable(&var_list,
1229                                              l7vsBalancingDownQoSAlertOff_oid,
1230                                              OID_LENGTH(l7vsBalancingDownQoSAlertOff_oid),
1231                                              ASN_OCTET_STR,
1232                                              (u_char*)in_trapmessage.c_str(),
1233                                              in_trapmessage.length());
1234         if (!ret_list) {
1235                 std::string msg("snmp_varlist_add_variable failed.");
1236                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 52, msg, __FILE__, __LINE__);
1237                 return SNMP_ERR_GENERR;
1238         }
1239         /*
1240          * Add any extra (optional) objects here
1241          */
1242
1243         /*
1244          * Send the trap to the list of configured destinations
1245          *  and clean up
1246          */
1247         send_v2trap(var_list);
1248         snmp_free_varbind(var_list);
1249
1250         return SNMP_ERR_NOERROR;
1251 }
1252
1253 /*!
1254  * send session pool alert on trap.
1255  *
1256  * @param[in]      std::string is trap message
1257  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1258  */
1259 int
1260 trap_sessionpool_alert_on(const std::string &in_trapmessage)
1261 {
1262         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 107, "snmpfunc::trap_sessionpool_alert_on", __FILE__, __LINE__);
1263
1264         /*-------- DEBUG LOG --------*/
1265         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1266                 std::stringstream    debugstr;
1267                 debugstr << "snmpfunc::trap_sessionpool_alert_on arguments:";
1268                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1269                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 108, debugstr.str(), __FILE__, __LINE__);
1270         }
1271         /*------ DEBUG LOG END ------*/
1272
1273         netsnmp_variable_list *var_list = NULL;
1274         netsnmp_variable_list *ret_list = NULL;
1275         oid       l7vsBalancingSessionPoolAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 11 };
1276
1277         /*
1278          * Set the snmpTrapOid.0 value
1279          */
1280         ret_list = snmp_varlist_add_variable(&var_list,
1281                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1282                                              ASN_OBJECT_ID,
1283                                              (u_char*)l7vsBalancingSessionPoolAlertOn_oid,
1284                                              sizeof(l7vsBalancingSessionPoolAlertOn_oid));
1285         if (!ret_list) {
1286                 std::string msg("snmp_varlist_add_variable failed.");
1287                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 53, msg, __FILE__, __LINE__);
1288                 return SNMP_ERR_GENERR;
1289         }
1290
1291         ret_list = snmp_varlist_add_variable(&var_list,
1292                                              l7vsBalancingSessionPoolAlertOn_oid,
1293                                              OID_LENGTH(l7vsBalancingSessionPoolAlertOn_oid),
1294                                              ASN_OCTET_STR,
1295                                              (u_char*)in_trapmessage.c_str(),
1296                                              in_trapmessage.length());
1297         if (!ret_list) {
1298                 std::string msg("snmp_varlist_add_variable failed.");
1299                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 54, msg, __FILE__, __LINE__);
1300                 return SNMP_ERR_GENERR;
1301         }
1302         /*
1303          * Add any extra (optional) objects here
1304          */
1305
1306         /*
1307          * Send the trap to the list of configured destinations
1308          *  and clean up
1309          */
1310         send_v2trap(var_list);
1311         snmp_free_varbind(var_list);
1312
1313         return SNMP_ERR_NOERROR;
1314 }
1315
1316 /*!
1317  * send session pool alert off trap.
1318  *
1319  * @param[in]      std::string is trap message
1320  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1321  */
1322 int
1323 trap_sessionpool_alert_off(const std::string &in_trapmessage)
1324 {
1325         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 109, "snmpfunc::trap_sessionpool_alert_off", __FILE__, __LINE__);
1326
1327         /*-------- DEBUG LOG --------*/
1328         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1329                 std::stringstream    debugstr;
1330                 debugstr << "snmpfunc::trap_sessionpool_alert_off arguments:";
1331                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1332                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 110, debugstr.str(), __FILE__, __LINE__);
1333         }
1334         /*------ DEBUG LOG END ------*/
1335
1336         netsnmp_variable_list *var_list = NULL;
1337         netsnmp_variable_list *ret_list = NULL;
1338         oid       l7vsBalancingSessionPoolAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 12 };
1339
1340         /*
1341          * Set the snmpTrapOid.0 value
1342          */
1343         ret_list = snmp_varlist_add_variable(&var_list,
1344                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1345                                              ASN_OBJECT_ID,
1346                                              (u_char*)l7vsBalancingSessionPoolAlertOff_oid,
1347                                              sizeof
1348                                              (l7vsBalancingSessionPoolAlertOff_oid));
1349         if (!ret_list) {
1350                 std::string msg("snmp_varlist_add_variable failed.");
1351                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 55, msg, __FILE__, __LINE__);
1352                 return SNMP_ERR_GENERR;
1353         }
1354
1355         ret_list = snmp_varlist_add_variable(&var_list,
1356                                              l7vsBalancingSessionPoolAlertOff_oid,
1357                                              OID_LENGTH(l7vsBalancingSessionPoolAlertOff_oid),
1358                                              ASN_OCTET_STR,
1359                                              (u_char*)in_trapmessage.c_str(),
1360                                              in_trapmessage.length());
1361         if (!ret_list) {
1362                 std::string msg("snmp_varlist_add_variable failed.");
1363                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 56, msg, __FILE__, __LINE__);
1364                 return SNMP_ERR_GENERR;
1365         }
1366         /*
1367          * Add any extra (optional) objects here
1368          */
1369
1370         /*
1371          * Send the trap to the list of configured destinations
1372          *  and clean up
1373          */
1374         send_v2trap(var_list);
1375         snmp_free_varbind(var_list);
1376
1377         return SNMP_ERR_NOERROR;
1378 }
1379
1380 /*!
1381  * send fatal log trap.
1382  *
1383  * @param[in]      std::string is trap message
1384  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1385  */
1386 int
1387 trap_fatal(const std::string &in_trapmessage)
1388 {
1389         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 111, "snmpfunc::trap_fatal", __FILE__, __LINE__);
1390
1391         /*-------- DEBUG LOG --------*/
1392         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1393                 std::stringstream    debugstr;
1394                 debugstr << "snmpfunc::trap_fatal arguments:";
1395                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1396                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 112, debugstr.str(), __FILE__, __LINE__);
1397         }
1398         /*------ DEBUG LOG END ------*/
1399
1400         netsnmp_variable_list *var_list = NULL;
1401         netsnmp_variable_list *ret_list = NULL;
1402         oid       l7vsLogFatal_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 1 };
1403         /*
1404          * Set the snmpTrapOid.0 value
1405          */
1406         ret_list = snmp_varlist_add_variable(&var_list,
1407                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1408                                              ASN_OBJECT_ID,
1409                                              (u_char*)l7vsLogFatal_oid, sizeof(l7vsLogFatal_oid));
1410         if (!ret_list) {
1411                 std::string msg("snmp_varlist_add_variable failed.");
1412                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 57, msg, __FILE__, __LINE__);
1413                 return SNMP_ERR_GENERR;
1414         }
1415
1416         ret_list = snmp_varlist_add_variable(&var_list,
1417                                              l7vsLogFatal_oid,
1418                                              OID_LENGTH(l7vsLogFatal_oid),
1419                                              ASN_OCTET_STR,
1420                                              (u_char*)in_trapmessage.c_str(),
1421                                              in_trapmessage.length());
1422         if (!ret_list) {
1423                 std::string msg("snmp_varlist_add_variable failed.");
1424                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 58, msg, __FILE__, __LINE__);
1425                 return SNMP_ERR_GENERR;
1426         }
1427         /*
1428          * Add any extra (optional) objects here
1429          */
1430
1431         /*
1432          * Send the trap to the list of configured destinations
1433          *  and clean up
1434          */
1435         send_v2trap(var_list);
1436         snmp_free_varbind(var_list);
1437
1438         return SNMP_ERR_NOERROR;
1439 }
1440
1441 /*!
1442  * send error log trap.
1443  *
1444  * @param[in]      std::string is trap message
1445  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1446  */
1447 int
1448 trap_error(const std::string &in_trapmessage)
1449 {
1450         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 113, "snmpfunc::trap_error", __FILE__, __LINE__);
1451
1452         /*-------- DEBUG LOG --------*/
1453         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1454                 std::stringstream    debugstr;
1455                 debugstr << "snmpfunc::trap_error arguments:";
1456                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1457                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 114, debugstr.str(), __FILE__, __LINE__);
1458         }
1459         /*------ DEBUG LOG END ------*/
1460
1461         netsnmp_variable_list *var_list = NULL;
1462         netsnmp_variable_list *ret_list = NULL;
1463         oid       l7vsLogError_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 2 };
1464
1465         /*
1466          * Set the snmpTrapOid.0 value
1467          */
1468         ret_list = snmp_varlist_add_variable(&var_list,
1469                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1470                                              ASN_OBJECT_ID,
1471                                              (u_char*)l7vsLogError_oid, sizeof(l7vsLogError_oid));
1472         if (!ret_list) {
1473                 std::string msg("snmp_varlist_add_variable failed.");
1474                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 59, msg, __FILE__, __LINE__);
1475                 return SNMP_ERR_GENERR;
1476         }
1477
1478         ret_list = snmp_varlist_add_variable(&var_list,
1479                                              l7vsLogError_oid,
1480                                              OID_LENGTH(l7vsLogError_oid),
1481                                              ASN_OCTET_STR,
1482                                              (u_char*)in_trapmessage.c_str(),
1483                                              in_trapmessage.length());
1484         if (!ret_list) {
1485                 std::string msg("snmp_varlist_add_variable failed.");
1486                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 60, msg, __FILE__, __LINE__);
1487                 return SNMP_ERR_GENERR;
1488         }
1489         /*
1490          * Add any extra (optional) objects here
1491          */
1492
1493         /*
1494          * Send the trap to the list of configured destinations
1495          *  and clean up
1496          */
1497         send_v2trap(var_list);
1498         snmp_free_varbind(var_list);
1499
1500         return SNMP_ERR_NOERROR;
1501 }
1502
1503 /*!
1504  * send warn log trap.
1505  *
1506  * @param[in]      std::string is trap message
1507  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1508  */
1509 int
1510 trap_warn(const std::string &in_trapmessage)
1511 {
1512         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 115, "snmpfunc::trap_warn", __FILE__, __LINE__);
1513
1514         /*-------- DEBUG LOG --------*/
1515         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1516                 std::stringstream    debugstr;
1517                 debugstr << "snmpfunc::trap_warn arguments:";
1518                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1519                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 116, debugstr.str(), __FILE__, __LINE__);
1520         }
1521         /*------ DEBUG LOG END ------*/
1522
1523         netsnmp_variable_list *var_list = NULL;
1524         netsnmp_variable_list *ret_list = NULL;
1525         oid       l7vsLogWarn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 3 };
1526
1527         /*
1528          * Set the snmpTrapOid.0 value
1529          */
1530         ret_list = snmp_varlist_add_variable(&var_list,
1531                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1532                                              ASN_OBJECT_ID,
1533                                              (u_char*)l7vsLogWarn_oid, sizeof(l7vsLogWarn_oid));
1534         if (!ret_list) {
1535                 std::string msg("snmp_varlist_add_variable failed.");
1536                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 61, msg, __FILE__, __LINE__);
1537                 return SNMP_ERR_GENERR;
1538         }
1539
1540         ret_list = snmp_varlist_add_variable(&var_list,
1541                                              l7vsLogWarn_oid,
1542                                              OID_LENGTH(l7vsLogWarn_oid),
1543                                              ASN_OCTET_STR,
1544                                              (u_char*)in_trapmessage.c_str(),
1545                                              in_trapmessage.length());
1546         if (!ret_list) {
1547                 std::string msg("snmp_varlist_add_variable failed.");
1548                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 62, msg, __FILE__, __LINE__);
1549                 return SNMP_ERR_GENERR;
1550         }
1551         /*
1552          * Add any extra (optional) objects here
1553          */
1554
1555         /*
1556          * Send the trap to the list of configured destinations
1557          *  and clean up
1558          */
1559         send_v2trap(var_list);
1560         snmp_free_varbind(var_list);
1561
1562         return SNMP_ERR_NOERROR;
1563 }
1564
1565 /*!
1566  * send info log trap.
1567  *
1568  * @param[in]      std::string is trap message
1569  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1570  */
1571 int
1572 trap_info(const std::string &in_trapmessage)
1573 {
1574         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 117, "snmpfunc::trap_info", __FILE__, __LINE__);
1575
1576         /*-------- DEBUG LOG --------*/
1577         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1578                 std::stringstream    debugstr;
1579                 debugstr << "snmpfunc::trap_info arguments:";
1580                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1581                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 118, debugstr.str(), __FILE__, __LINE__);
1582         }
1583         /*------ DEBUG LOG END ------*/
1584
1585         netsnmp_variable_list *var_list = NULL;
1586         netsnmp_variable_list *ret_list = NULL;
1587         oid       l7vsLogInfo_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 4 };
1588
1589         /*
1590          * Set the snmpTrapOid.0 value
1591          */
1592         ret_list = snmp_varlist_add_variable(&var_list,
1593                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1594                                              ASN_OBJECT_ID,
1595                                              (u_char*)l7vsLogInfo_oid, sizeof(l7vsLogInfo_oid));
1596         if (!ret_list) {
1597                 std::string msg("snmp_varlist_add_variable failed.");
1598                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 63, msg, __FILE__, __LINE__);
1599                 return SNMP_ERR_GENERR;
1600         }
1601
1602         ret_list = snmp_varlist_add_variable(&var_list,
1603                                              l7vsLogInfo_oid,
1604                                              OID_LENGTH(l7vsLogInfo_oid),
1605                                              ASN_OCTET_STR,
1606                                              (u_char*)in_trapmessage.c_str(),
1607                                              in_trapmessage.length());
1608         if (!ret_list) {
1609                 std::string msg("snmp_varlist_add_variable failed.");
1610                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 64, msg, __FILE__, __LINE__);
1611                 return SNMP_ERR_GENERR;
1612         }
1613         /*
1614          * Add any extra (optional) objects here
1615          */
1616
1617         /*
1618          * Send the trap to the list of configured destinations
1619          *  and clean up
1620          */
1621         send_v2trap(var_list);
1622         snmp_free_varbind(var_list);
1623
1624         return SNMP_ERR_NOERROR;
1625 }
1626
1627 /*!
1628  * send debug log trap.
1629  *
1630  * @param[in]      std::string is trap message
1631  * @retrun         int  success:SNMP_ERR_NOERROR  failed:SNMP_ERR_GENERR
1632  */
1633 int
1634 trap_debug(const std::string &in_trapmessage)
1635 {
1636         Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 119, "snmpfunc::trap_debug", __FILE__, __LINE__);
1637
1638         /*-------- DEBUG LOG --------*/
1639         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
1640                 std::stringstream    debugstr;
1641                 debugstr << "snmpfunc::trap_debug arguments:";
1642                 debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
1643                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 120, debugstr.str(), __FILE__, __LINE__);
1644         }
1645         /*------ DEBUG LOG END ------*/
1646
1647         netsnmp_variable_list *var_list = NULL;
1648         netsnmp_variable_list *ret_list = NULL;
1649         oid       l7vsLogDebug_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 5 };
1650
1651         /*
1652          * Set the snmpTrapOid.0 value
1653          */
1654         ret_list = snmp_varlist_add_variable(&var_list,
1655                                              snmptrap_oid, OID_LENGTH(snmptrap_oid),
1656                                              ASN_OBJECT_ID,
1657                                              (u_char*)l7vsLogDebug_oid, sizeof(l7vsLogDebug_oid));
1658         if (!ret_list) {
1659                 std::string msg("snmp_varlist_add_variable failed.");
1660                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 65, msg, __FILE__, __LINE__);
1661                 return SNMP_ERR_GENERR;
1662         }
1663
1664         ret_list = snmp_varlist_add_variable(&var_list,
1665                                              l7vsLogDebug_oid,
1666                                              OID_LENGTH(l7vsLogDebug_oid),
1667                                              ASN_OCTET_STR,
1668                                              (u_char*)in_trapmessage.c_str(),
1669                                              in_trapmessage.length());
1670         if (!ret_list) {
1671                 std::string msg("snmp_varlist_add_variable failed.");
1672                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 66, msg, __FILE__, __LINE__);
1673                 return SNMP_ERR_GENERR;
1674         }
1675         /*
1676          * Add any extra (optional) objects here
1677          */
1678
1679         /*
1680          * Send the trap to the list of configured destinations
1681          *  and clean up
1682          */
1683         send_v2trap(var_list);
1684         snmp_free_varbind(var_list);
1685
1686         return SNMP_ERR_NOERROR;
1687 }