snmpagent/store_mibdata.cpp

   1 //
   2 //!    @file    store_mibdata.cpp
   3 //!    @brief    net-snmp mibdata stored source
   4 //
   5 //    Copyright (C) 2008  NTT COMWARE Corporation.
   6 //
   7 //    Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 //    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #include "store_mibdata.h"
  12
  13 vsdata    *l7ag_store_mibdata::getVS_first_data_point()
  14 {
  15         return &vsdatalist.front();
  16 }
  17
  18 std::vector<vsdata>::iterator    l7ag_store_mibdata::getVS_first_data_iterator()
  19 {
  20         return vsdatalist.begin();
  21 }
  22
  23 vsdata    *l7ag_store_mibdata::getVS_data_point(std::vector<vsdata>::iterator in_it)
  24 {
  25         if (vsdatalist.end() == in_it) {
  26                 return NULL;
  27         }
  28         for (unsigned int i = 0; i < vsdatalist.size(); i++) {
  29                 if (vsdatalist[i].index == in_it->index) {
  30                         return &vsdatalist[i];
  31                 }
  32         }
  33         return NULL;
  34 }
  35
  36 std::size_t    l7ag_store_mibdata::getVSdatacount()
  37 {
  38         return vsdatalist.size();
  39 }
  40
  41 vsdata    *l7ag_store_mibdata::getVSmibdata(std::size_t n)
  42 {
  43         if (vsdatalist.size() <= n) {
  44                 return NULL;
  45         }
  46         return &vsdatalist[n];
  47 }
  48
  49 vsdata    *l7ag_store_mibdata::updateVSmibdata(std::size_t n, l7ag_mibdata_payload_vs *in_data)
  50 {
  51         oid   index[1];
  52         netsnmp_table_row *row;
  53
  54         if (vsdatalist.size() <= n) {
  55                 return NULL;
  56         }
  57         if (in_data == NULL) {
  58                 for (size_t i = vsdatalist.size(); i > n; i--) {
  59                         index[0] = i;
  60                         row = netsnmp_table_data_get_from_oid(vs_table_set->table, index, 1);
  61                         netsnmp_table_dataset_remove_and_delete_row(vs_table_set, row);
  62                         vsdatalist.pop_back();
  63                 }
  64                 return NULL;
  65         }
  66
  67         vsdatalist[n].index = in_data->index;
  68         switch (in_data->protocol) {
  69         case IPPROTO_TCP:
  70                 vsdatalist[n].protocol = 1;
  71                 break;
  72         case IPPROTO_UDP:
  73                 vsdatalist[n].protocol = 2;
  74                 break;
  75         default:
  76                 vsdatalist[n].protocol = 0;
  77                 break;
  78         }
  79         struct in_addr vip_in = { in_data->ipAddress };
  80         char *vip = inet_ntoa(vip_in);
  81         strncpy(vsdatalist[n].ipAddress, vip, L7VS_IPADDR_LEN);
  82         vsdatalist[n].portNumber    = ntohs(in_data->portNumber);
  83         strncpy(vsdatalist[n].scheduleModule, in_data->scheduleModule, L7VS_MODNAME_LEN);
  84         strncpy(vsdatalist[n].protocolModule, in_data->protocolModule, L7VS_MODNAME_LEN);
  85         strncpy(vsdatalist[n].protocolModuleOption, in_data->protocolModuleOption, L7VS_PROTOMOD_OPT_LEN);
  86         switch (in_data->reschedule) {
  87         case 0:
  88                 vsdatalist[n].reschedule = 2;
  89                 break;
  90         case 1:
  91                 vsdatalist[n].reschedule = 1;
  92                 break;
  93         default:
  94                 vsdatalist[n].reschedule = 0;
  95                 break;
  96         }
  97         struct in_addr sorry_in = { in_data->sorryIpAddress };
  98         char *sorry = inet_ntoa(sorry_in);
  99         strncpy(vsdatalist[n].sorryIpAddress, sorry, L7VS_IPADDR_LEN);
 100         vsdatalist[n].sorryPortNumber   = ntohs(in_data->sorryPortNumber);
 101         vsdatalist[n].sorryThreshold    = in_data->sorryThreshold;
 102         switch (in_data->sorryForceFlag) {
 103         case 0:
 104                 vsdatalist[n].sorryForceFlag = 2;
 105                 break;
 106         case 1:
 107                 vsdatalist[n].sorryForceFlag = 1;
 108                 break;
 109         default:
 110                 vsdatalist[n].sorryForceFlag = 0;
 111                 break;
 112         }
 113         vsdatalist[n].QoSThresholdUp    = in_data->QoSThresholdUp   * 8;
 114         vsdatalist[n].QoSThresholdDown  = in_data->QoSThresholdDown * 8;
 115         vsdatalist[n].throughputUp      = in_data->throughputUp     * 8;
 116         vsdatalist[n].throughputDown    = in_data->throughputDown   * 8;
 117
 118         if (vs_table_set == NULL) {
 119                 return false;
 120         }
 121         index[0] = vsdatalist[n].index;
 122         row = netsnmp_table_data_get_from_oid(vs_table_set->table, index, 1);
 123         if (row == NULL) {
 124 //        row = netsnmp_table_data_set_create_row_from_defaults(vs_table_set->default_row);
 125                 row = netsnmp_create_table_data_row();
 126                 if (row == NULL) return false;
 127                 netsnmp_table_row_add_index(row, ASN_INTEGER, (char *)&vsdatalist[n].index, sizeof(unsigned short));
 128                 netsnmp_table_dataset_add_row(vs_table_set, row);
 129         }
 130
 131         netsnmp_set_row_column(row, COLUMN_UM7VSINDEX, ASN_INTEGER, (char *) &vsdatalist[n].index, sizeof(unsigned short));
 132         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOL, ASN_INTEGER, (char *) &vsdatalist[n].protocol, sizeof(unsigned char));
 133         netsnmp_set_row_column(row, COLUMN_UM7VSIPADDRESS, ASN_OCTET_STR, vsdatalist[n].ipAddress, strnlen(vsdatalist[n].ipAddress, L7VS_IPADDR_LEN));
 134         netsnmp_set_row_column(row, COLUMN_UM7VSPORTNUMBER, ASN_UNSIGNED, (char *) &vsdatalist[n].portNumber, sizeof(unsigned short));
 135         netsnmp_set_row_column(row, COLUMN_UM7VSSCHEDULEMODULE, ASN_OCTET_STR, (char *) &vsdatalist[n].scheduleModule, L7VS_MODNAME_LEN);
 136         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOLMODULE, ASN_OCTET_STR, (char *) &vsdatalist[n].protocolModule, L7VS_MODNAME_LEN);
 137         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOLMODULEOPTION, ASN_OCTET_STR, (char *) &vsdatalist[n].protocolModuleOption, L7VS_PROTOMOD_OPT_LEN);
 138         netsnmp_set_row_column(row, COLUMN_UM7VSRESCHEDULE, ASN_INTEGER, (char *) &vsdatalist[n].reschedule, sizeof(unsigned char));
 139         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYIPADDRESS, ASN_OCTET_STR, vsdatalist[n].sorryIpAddress, strnlen(vsdatalist[n].sorryIpAddress, L7VS_IPADDR_LEN));
 140         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYPORTNUMBER, ASN_UNSIGNED, (char *) &vsdatalist[n].sorryPortNumber, sizeof(unsigned short));
 141         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYTHRESHOLD, ASN_INTEGER, (char *) &vsdatalist[n].sorryThreshold, sizeof(unsigned int));
 142         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYFORCEFLAG, ASN_INTEGER, (char *) &vsdatalist[n].sorryForceFlag, sizeof(unsigned char));
 143         netsnmp_set_row_column(row, COLUMN_UM7VSQOSTHRESHOLDUP, ASN_INTEGER, (char *) &vsdatalist[n].QoSThresholdUp, sizeof(unsigned long long));
 144         netsnmp_set_row_column(row, COLUMN_UM7VSQOSTHRESHOLDDOWN, ASN_INTEGER, (char *) &vsdatalist[n].QoSThresholdDown, sizeof(unsigned long long));
 145         netsnmp_set_row_column(row, COLUMN_UM7VSTHROUGHPUTUP, ASN_INTEGER, (char *) &vsdatalist[n].throughputUp, sizeof(unsigned long long));
 146         netsnmp_set_row_column(row, COLUMN_UM7VSTHROUGHPUTDOWN, ASN_INTEGER, (char *) &vsdatalist[n].throughputDown, sizeof(unsigned long long));
 147
 148         return &vsdatalist[n];
 149 }
 150
 151 bool    l7ag_store_mibdata::addVSmibdata(l7ag_mibdata_payload_vs *in_data)
 152 {
 153         oid   index[1];
 154         netsnmp_table_row *row;
 155         vsdata    data;
 156
 157         if (NULL == in_data) {
 158                 return false;
 159         }
 160
 161         data.index = in_data->index;
 162         switch (in_data->protocol) {
 163         case IPPROTO_TCP:
 164                 data.protocol = 1;
 165                 break;
 166         case IPPROTO_UDP:
 167                 data.protocol = 2;
 168                 break;
 169         default:
 170                 data.protocol = 0;
 171                 break;
 172         }
 173         struct in_addr vip_in = { in_data->ipAddress };
 174         char *vip = inet_ntoa(vip_in);
 175         strncpy(data.ipAddress, vip, L7VS_IPADDR_LEN);
 176         data.portNumber = ntohs(in_data->portNumber);
 177         strncpy(data.scheduleModule, in_data->scheduleModule, L7VS_MODNAME_LEN);
 178         strncpy(data.protocolModule, in_data->protocolModule, L7VS_MODNAME_LEN);
 179         strncpy(data.protocolModuleOption, in_data->protocolModuleOption, L7VS_PROTOMOD_OPT_LEN);
 180         switch (in_data->reschedule) {
 181         case 0:
 182                 data.reschedule = 2;
 183                 break;
 184         case 1:
 185                 data.reschedule = 1;
 186                 break;
 187         default:
 188                 data.reschedule = 0;
 189                 break;
 190         }
 191         struct in_addr sorry_in = { in_data->sorryIpAddress };
 192         char *sorry = inet_ntoa(sorry_in);
 193         strncpy(data.sorryIpAddress, sorry, L7VS_IPADDR_LEN);
 194         data.sorryPortNumber    = ntohs(in_data->sorryPortNumber);
 195         data.sorryThreshold     = in_data->sorryThreshold;
 196         switch (in_data->sorryForceFlag) {
 197         case 0:
 198                 data.sorryForceFlag = 2;
 199                 break;
 200         case 1:
 201                 data.sorryForceFlag = 1;
 202                 break;
 203         default:
 204                 data.sorryForceFlag = 0;
 205                 break;
 206         }
 207         data.QoSThresholdUp     = in_data->QoSThresholdUp   * 8;
 208         data.QoSThresholdDown   = in_data->QoSThresholdDown * 8;
 209         data.throughputUp       = in_data->throughputUp     * 8;
 210         data.throughputDown     = in_data->throughputDown   * 8;
 211         vsdatalist.push_back(data);
 212
 213         if (vs_table_set == NULL) {
 214                 return false;
 215         }
 216         index[0] = data.index;
 217         row = netsnmp_table_data_get_from_oid(vs_table_set->table, index, 1);
 218         if (row == NULL) {
 219 //        row = netsnmp_table_data_set_create_row_from_defaults(vs_table_set->default_row);
 220                 row = netsnmp_create_table_data_row();
 221                 if (row == NULL) return false;
 222                 netsnmp_table_row_add_index(row, ASN_INTEGER, (char *)&data.index, sizeof(unsigned short));
 223                 netsnmp_table_dataset_add_row(vs_table_set, row);
 224         }
 225
 226         netsnmp_set_row_column(row, COLUMN_UM7VSINDEX, ASN_INTEGER, (char *) &data.index, sizeof(unsigned short));
 227         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOL, ASN_INTEGER, (char *) &data.protocol, sizeof(unsigned char));
 228         netsnmp_set_row_column(row, COLUMN_UM7VSIPADDRESS, ASN_OCTET_STR, data.ipAddress, strnlen(data.ipAddress, L7VS_IPADDR_LEN));
 229         netsnmp_set_row_column(row, COLUMN_UM7VSPORTNUMBER, ASN_UNSIGNED, (char *) &data.portNumber, sizeof(unsigned short));
 230         netsnmp_set_row_column(row, COLUMN_UM7VSSCHEDULEMODULE, ASN_OCTET_STR, (char *) &data.scheduleModule, L7VS_MODNAME_LEN);
 231         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOLMODULE, ASN_OCTET_STR, (char *) &data.protocolModule, L7VS_MODNAME_LEN);
 232         netsnmp_set_row_column(row, COLUMN_UM7VSPROTOCOLMODULEOPTION, ASN_OCTET_STR, (char *) &data.protocolModuleOption, L7VS_PROTOMOD_OPT_LEN);
 233         netsnmp_set_row_column(row, COLUMN_UM7VSRESCHEDULE, ASN_INTEGER, (char *) &data.reschedule, sizeof(unsigned char));
 234         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYIPADDRESS, ASN_OCTET_STR, data.sorryIpAddress, strnlen(data.sorryIpAddress, L7VS_IPADDR_LEN));
 235         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYPORTNUMBER, ASN_UNSIGNED, (char *) &data.sorryPortNumber, sizeof(unsigned short));
 236         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYTHRESHOLD, ASN_INTEGER, (char *) &data.sorryThreshold, sizeof(unsigned int));
 237         netsnmp_set_row_column(row, COLUMN_UM7VSSORRYFORCEFLAG, ASN_INTEGER, (char *) &data.sorryForceFlag, sizeof(unsigned char));
 238         netsnmp_set_row_column(row, COLUMN_UM7VSQOSTHRESHOLDUP, ASN_INTEGER, (char *) &data.QoSThresholdUp, sizeof(unsigned long long));
 239         netsnmp_set_row_column(row, COLUMN_UM7VSQOSTHRESHOLDDOWN, ASN_INTEGER, (char *) &data.QoSThresholdDown, sizeof(unsigned long long));
 240         netsnmp_set_row_column(row, COLUMN_UM7VSTHROUGHPUTUP, ASN_INTEGER, (char *) &data.throughputUp, sizeof(unsigned long long));
 241         netsnmp_set_row_column(row, COLUMN_UM7VSTHROUGHPUTDOWN, ASN_INTEGER, (char *) &data.throughputDown, sizeof(unsigned long long));
 242
 243         return true;
 244 }
 245
 246 void    l7ag_store_mibdata::clearVSmibdata()
 247 {
 248         oid   index[1];
 249         netsnmp_table_row *row;
 250         for (size_t i = 1; i <= vsdatalist.size(); i++) {
 251                 index[0] = i;
 252                 row = netsnmp_table_data_get_from_oid(vs_table_set->table, index, 1);
 253                 netsnmp_table_dataset_remove_and_delete_row(vs_table_set, row);
 254         }
 255         vsdatalist.clear();
 256 }
 257
 258 rsdata    *l7ag_store_mibdata::getRS_first_data_point()
 259 {
 260         return &rsdatalist.front();
 261 }
 262
 263 rsdata    *l7ag_store_mibdata::getRS_data_point(std::vector<rsdata>::iterator in_it)
 264 {
 265         if (rsdatalist.end() == in_it) {
 266                 return NULL;
 267         }
 268         for (size_t i = 0; i < rsdatalist.size(); i++) {
 269                 if (rsdatalist[i].index == in_it->index) {
 270                         return &rsdatalist[i];
 271                 }
 272         }
 273
 274         return NULL;
 275 }
 276
 277 std::vector<rsdata>::iterator    l7ag_store_mibdata::getRS_first_data_iterator()
 278 {
 279         return rsdatalist.begin();
 280 }
 281
 282 std::size_t    l7ag_store_mibdata::getRSdatacount()
 283 {
 284         return rsdatalist.size();
 285 }
 286
 287 rsdata    *l7ag_store_mibdata::getRSmibdata(std::size_t n)
 288 {
 289         if (rsdatalist.size() <= n) {
 290                 return NULL;
 291         }
 292         return &rsdatalist[n];
 293 }
 294
 295 rsdata    *l7ag_store_mibdata::updateRSmibdata(std::size_t n, l7ag_mibdata_payload_rs *in_data)
 296 {
 297         oid   index[1];
 298         netsnmp_table_row *row;
 299
 300         if (rsdatalist.size() <= n) {
 301                 return NULL;
 302         }
 303         if (in_data == NULL) {
 304                 for (size_t i = rsdatalist.size(); i > n; i--) {
 305                         index[0] = i;
 306                         row = netsnmp_table_data_get_from_oid(rs_table_set->table, index, 1);
 307                         netsnmp_table_dataset_remove_and_delete_row(rs_table_set, row);
 308                         rsdatalist.pop_back();
 309                 }
 310                 return NULL;
 311         }
 312
 313         rsdatalist[n].index                  = in_data->index;
 314         rsdatalist[n].virtualServiceIndex    = in_data->virtualServiceIndex;
 315         struct in_addr in = { in_data->ipAddress };
 316         char *ip = inet_ntoa(in);
 317         strncpy(rsdatalist[n].ipAddress, ip, L7VS_IPADDR_LEN);
 318         rsdatalist[n].portNumber             = ntohs(in_data->portNumber);
 319         rsdatalist[n].forwardMode            = in_data->forwardMode;
 320         rsdatalist[n].weight                 = in_data->weight;
 321         rsdatalist[n].activeConn             = in_data->activeConn;
 322         rsdatalist[n].inactiveConn           = in_data->inactiveConn;
 323
 324         if (rs_table_set == NULL) {
 325                 return false;
 326         }
 327         index[0] = rsdatalist[n].index;
 328         row = netsnmp_table_data_get_from_oid(rs_table_set->table, index, 1);
 329         if (row == NULL) {
 330 //        row = netsnmp_table_data_set_create_row_from_defaults(rs_table_set->default_row);
 331                 row = netsnmp_create_table_data_row();
 332                 if (row == NULL) return false;
 333                 netsnmp_table_row_add_index(row, ASN_INTEGER, (char *)&rsdatalist[n].index, sizeof(unsigned short));
 334                 netsnmp_table_dataset_add_row(rs_table_set, row);
 335         }
 336
 337         netsnmp_set_row_column(row, COLUMN_UM7RSINDEX, ASN_INTEGER, (char *) &rsdatalist[n].index, sizeof(unsigned short));
 338         netsnmp_set_row_column(row, COLUMN_UM7RSVIRTUALSERVICEINDEX, ASN_INTEGER, (char *) &rsdatalist[n].virtualServiceIndex, sizeof(unsigned short));
 339         netsnmp_set_row_column(row, COLUMN_UM7RSIPADDRESS, ASN_OCTET_STR, rsdatalist[n].ipAddress, strnlen(rsdatalist[n].ipAddress, L7VS_IPADDR_LEN));
 340         netsnmp_set_row_column(row, COLUMN_UM7RSPORTNUMBER, ASN_UNSIGNED, (char *) &rsdatalist[n].portNumber, sizeof(unsigned short));
 341         netsnmp_set_row_column(row, COLUMN_UM7RSFORWARDMODE, ASN_INTEGER, (char *) &rsdatalist[n].forwardMode, sizeof(unsigned short));
 342         netsnmp_set_row_column(row, COLUMN_UM7RSWEIGHT, ASN_INTEGER, (char *) &rsdatalist[n].weight, sizeof(unsigned int));
 343         netsnmp_set_row_column(row, COLUMN_UM7RSACTIVECONN, ASN_INTEGER, (char *) &rsdatalist[n].activeConn, sizeof(unsigned int));
 344         netsnmp_set_row_column(row, COLUMN_UM7RSINACTIVECONN, ASN_INTEGER, (char *) &rsdatalist[n].inactiveConn, sizeof(unsigned int));
 345
 346         return &rsdatalist[n];
 347 }
 348
 349 bool    l7ag_store_mibdata::addRSmibdata(l7ag_mibdata_payload_rs *in_data)
 350 {
 351         oid   index[1];
 352         netsnmp_table_row *row;
 353         rsdata data;
 354
 355         if (NULL == in_data) {
 356                 return false;
 357         }
 358
 359         data.index                  = in_data->index;
 360         data.virtualServiceIndex    = in_data->virtualServiceIndex;
 361         struct in_addr in = { in_data->ipAddress };
 362         char *ip = inet_ntoa(in);
 363         strncpy(data.ipAddress, ip, L7VS_IPADDR_LEN);
 364         data.portNumber             = ntohs(in_data->portNumber);
 365         data.forwardMode            = in_data->forwardMode;
 366         data.weight                 = in_data->weight;
 367         data.activeConn             = in_data->activeConn;
 368         data.inactiveConn           = in_data->inactiveConn;
 369
 370         rsdatalist.push_back(data);
 371
 372         if (rs_table_set == NULL) {
 373                 return false;
 374         }
 375         index[0] = data.index;
 376         row = netsnmp_table_data_get_from_oid(rs_table_set->table, index, 1);
 377         if (row == NULL) {
 378 //        row = netsnmp_table_data_set_create_row_from_defaults(rs_table_set->default_row);
 379                 row = netsnmp_create_table_data_row();
 380                 if (row == NULL) return false;
 381                 netsnmp_table_row_add_index(row, ASN_INTEGER, (char *)&data.index, sizeof(unsigned short));
 382                 netsnmp_table_dataset_add_row(rs_table_set, row);
 383         }
 384
 385         netsnmp_set_row_column(row, COLUMN_UM7RSINDEX, ASN_INTEGER, (char *) &data.index, sizeof(unsigned short));
 386         netsnmp_set_row_column(row, COLUMN_UM7RSVIRTUALSERVICEINDEX, ASN_INTEGER, (char *) &data.virtualServiceIndex, sizeof(unsigned short));
 387         netsnmp_set_row_column(row, COLUMN_UM7RSIPADDRESS, ASN_OCTET_STR, data.ipAddress, strnlen(data.ipAddress, L7VS_IPADDR_LEN));
 388         netsnmp_set_row_column(row, COLUMN_UM7RSPORTNUMBER, ASN_UNSIGNED, (char *) &data.portNumber, sizeof(unsigned short));
 389         netsnmp_set_row_column(row, COLUMN_UM7RSFORWARDMODE, ASN_INTEGER, (char *) &data.forwardMode, sizeof(unsigned short));
 390         netsnmp_set_row_column(row, COLUMN_UM7RSWEIGHT, ASN_INTEGER, (char *) &data.weight, sizeof(unsigned int));
 391         netsnmp_set_row_column(row, COLUMN_UM7RSACTIVECONN, ASN_INTEGER, (char *) &data.activeConn, sizeof(unsigned int));
 392         netsnmp_set_row_column(row, COLUMN_UM7RSINACTIVECONN, ASN_INTEGER, (char *) &data.inactiveConn, sizeof(unsigned int));
 393
 394         return true;
 395 }
 396
 397 void    l7ag_store_mibdata::clearRSmibdata()
 398 {
 399         oid   index[1];
 400         netsnmp_table_row *row;
 401         for (size_t i = 1; i <= rsdatalist.size(); i++) {
 402                 index[0] = i;
 403                 row = netsnmp_table_data_get_from_oid(rs_table_set->table, index, 1);
 404                 netsnmp_table_dataset_remove_and_delete_row(rs_table_set, row);
 405         }
 406         rsdatalist.clear();
 407 }
 408
 409 l7vsd_log_level    *l7ag_store_mibdata::getVsdLogmibdata()
 410 {
 411         return &vsd_log;
 412 }
 413
 414 l7vsadm_log_level    *l7ag_store_mibdata::getVsadmLogmibdata()
 415 {
 416         return &adm_log;
 417 }
 418
 419 l7snmpagent_log_level    *l7ag_store_mibdata::getAgentLogmibdata()
 420 {
 421         return &snmp_log;
 422 }
 423
 424 l7_status    *l7ag_store_mibdata::getStatmibdata()
 425 {
 426         return &status;
 427 }
 428
 429 void    l7ag_store_mibdata::clearVsdLogmibdata()
 430 {
 431         vsd_log.network                 = l7vs::LOG_LV_NONE;
 432         vsd_log.networkBandwidth        = l7vs::LOG_LV_NONE;
 433         vsd_log.networkNumConnection    = l7vs::LOG_LV_NONE;
 434         vsd_log.networkQoS              = l7vs::LOG_LV_NONE;
 435         vsd_log.virtualService          = l7vs::LOG_LV_NONE;
 436         vsd_log.realServer              = l7vs::LOG_LV_NONE;
 437         vsd_log.realServerBalancing     = l7vs::LOG_LV_NONE;
 438         vsd_log.sorryServer             = l7vs::LOG_LV_NONE;
 439         vsd_log.replication             = l7vs::LOG_LV_NONE;
 440         vsd_log.startStop               = l7vs::LOG_LV_NONE;
 441         vsd_log.system                  = l7vs::LOG_LV_NONE;
 442         vsd_log.systemMemory            = l7vs::LOG_LV_NONE;
 443         vsd_log.systemSocket            = l7vs::LOG_LV_NONE;
 444         vsd_log.systemSignal            = l7vs::LOG_LV_NONE;
 445         vsd_log.environment             = l7vs::LOG_LV_NONE;
 446         vsd_log.environmentParameter    = l7vs::LOG_LV_NONE;
 447         vsd_log.logger                  = l7vs::LOG_LV_NONE;
 448         vsd_log.parameter               = l7vs::LOG_LV_NONE;
 449         vsd_log.event                   = l7vs::LOG_LV_NONE;
 450         vsd_log.schedule                = l7vs::LOG_LV_NONE;
 451         vsd_log.program                 = l7vs::LOG_LV_NONE;
 452         vsd_log.protocol                = l7vs::LOG_LV_NONE;
 453         vsd_log.module                  = l7vs::LOG_LV_NONE;
 454 }
 455
 456 void    l7ag_store_mibdata::clearVsadmLogmibdata()
 457 {
 458         adm_log.parse           = l7vs::LOG_LV_NONE;
 459         adm_log.operate         = l7vs::LOG_LV_NONE;
 460         adm_log.communicate     = l7vs::LOG_LV_NONE;
 461         adm_log.configResult    = l7vs::LOG_LV_NONE;
 462         adm_log.common          = l7vs::LOG_LV_NONE;
 463         adm_log.logger          = l7vs::LOG_LV_NONE;
 464         adm_log.parameter       = l7vs::LOG_LV_NONE;
 465         adm_log.protocol        = l7vs::LOG_LV_NONE;
 466         adm_log.module          = l7vs::LOG_LV_NONE;
 467 }
 468
 469 void    l7ag_store_mibdata::clearAgentLogmibdata()
 470 {
 471         snmp_log.startStop      = l7vs::LOG_LV_NONE;
 472         snmp_log.managerReceive = l7vs::LOG_LV_NONE;
 473         snmp_log.managerSend    = l7vs::LOG_LV_NONE;
 474         snmp_log.l7vsdReceive   = l7vs::LOG_LV_NONE;
 475         snmp_log.l7vsdSend      = l7vs::LOG_LV_NONE;
 476         snmp_log.logger         = l7vs::LOG_LV_NONE;
 477         snmp_log.parameter      = l7vs::LOG_LV_NONE;
 478 }
 479
 480 void    l7ag_store_mibdata::clearStatmibdata()
 481 {
 482         memset(&status.message, 0, DISPLAYSTRING_LEN);
 483         status.snmpAgent    = UNKNOWN;
 484 //    status.replication  = l7vs::replication::REPLICATION_OUT;
 485 }
 486
 487 void    l7ag_store_mibdata::setVsdLogmibdata(l7vsd_log_level log)
 488 {
 489         vsd_log.network                 = log.network;
 490         vsd_log.networkBandwidth        = log.networkBandwidth;
 491         vsd_log.networkNumConnection    = log.networkNumConnection;
 492         vsd_log.networkQoS              = log.networkQoS;
 493         vsd_log.virtualService          = log.virtualService;
 494         vsd_log.realServer              = log.realServer;
 495         vsd_log.realServerBalancing     = log.realServerBalancing;
 496         vsd_log.sorryServer             = log.sorryServer;
 497         vsd_log.replication             = log.replication;
 498         vsd_log.startStop               = log.startStop;
 499         vsd_log.system                  = log.system;
 500         vsd_log.systemMemory            = log.systemMemory;
 501         vsd_log.systemSocket            = log.systemSocket;
 502         vsd_log.systemSignal            = log.systemSignal;
 503         vsd_log.environment             = log.environment;
 504         vsd_log.environmentParameter    = log.environmentParameter;
 505         vsd_log.logger                  = log.logger;
 506         vsd_log.parameter               = log.parameter;
 507         vsd_log.event                   = log.event;
 508         vsd_log.schedule                = log.schedule;
 509         vsd_log.program                 = log.program;
 510         vsd_log.protocol                = log.protocol;
 511         vsd_log.module                  = log.module;
 512 }
 513
 514 void    l7ag_store_mibdata::setVsadmLogmibdata(l7vsadm_log_level log)
 515 {
 516         adm_log.parse           = log.parse;
 517         adm_log.operate         = log.operate;
 518         adm_log.communicate     = log.communicate;
 519         adm_log.configResult    = log.configResult;
 520         adm_log.common          = log.common;
 521         adm_log.logger          = log.logger;
 522         adm_log.parameter       = log.parameter;
 523         adm_log.protocol        = log.protocol;
 524         adm_log.module          = log.module;
 525 }
 526
 527 void    l7ag_store_mibdata::setAgentLogmibdata(l7snmpagent_log_level log)
 528 {
 529         snmp_log.startStop      = log.startStop;
 530         snmp_log.managerReceive = log.managerReceive;
 531         snmp_log.managerSend    = log.managerSend;
 532         snmp_log.l7vsdReceive   = log.l7vsdReceive;
 533         snmp_log.l7vsdSend      = log.l7vsdSend;
 534         snmp_log.logger         = log.logger;
 535         snmp_log.parameter      = log.parameter;
 536 }
 537
 538 void    l7ag_store_mibdata::setStatmibdata(l7_status stat)
 539 {
 540         memcpy(&status.message, &stat.message, strnlen(stat.message, DISPLAYSTRING_LEN));
 541         status.snmpAgent    = stat.snmpAgent;
 542 //     status.replication  = stat.replication;
 543 }
 544
 545 void    l7ag_store_mibdata::setVsTableSet(netsnmp_table_data_set *table_set)
 546 {
 547         vs_table_set = table_set;
 548 }
 549
 550 void    l7ag_store_mibdata::setRsTableSet(netsnmp_table_data_set *table_set)
 551 {
 552         rs_table_set = table_set;
 553 }