src/snmp/Pdu.cc

   1 /*
   2  * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 49    SNMP Interface */
  10
  11 #include "squid.h"
  12 #include "base/TextException.h"
  13 #include "ipc/TypedMsgHdr.h"
  14 #include "snmp/Pdu.h"
  15 #include "snmp/Var.h"
  16 #include "snmp_core.h"
  17 #include "tools.h"
  18
  19 #include <algorithm>
  20
  21 Snmp::Pdu::Pdu()
  22 {
  23     init();
  24 }
  25
  26 Snmp::Pdu::Pdu(const Pdu& pdu)
  27 {
  28     init();
  29     assign(pdu);
  30 }
  31
  32 Snmp::Pdu::~Pdu()
  33 {
  34     clear();
  35 }
  36
  37 Snmp::Pdu&
  38 Snmp::Pdu::operator = (const Pdu& pdu)
  39 {
  40     clear();
  41     assign(pdu);
  42     return *this;
  43 }
  44
  45 void
  46 Snmp::Pdu::init()
  47 {
  48     memset(static_cast<snmp_pdu *>(this), 0, sizeof(snmp_pdu));
  49     aggrCount = 0;
  50     errstat = SNMP_DEFAULT_ERRSTAT;
  51     errindex = SNMP_DEFAULT_ERRINDEX;
  52 }
  53
  54 void
  55 Snmp::Pdu::aggregate(const Pdu& pdu)
  56 {
  57     Must(varCount() == pdu.varCount());
  58     ++aggrCount;
  59     for (variable_list* p_aggr = variables, *p_var = pdu.variables; p_var != nullptr;
  60             p_aggr = p_aggr->next_variable, p_var = p_var->next_variable) {
  61         Must(p_aggr != nullptr);
  62         Var& aggr = static_cast<Var&>(*p_aggr);
  63         Var& var = static_cast<Var&>(*p_var);
  64         if (aggr.isNull()) {
  65             aggr.setName(var.getName());
  66             aggr.copyValue(var);
  67         } else {
  68             switch (snmpAggrType(aggr.name, aggr.name_length)) {
  69             case atSum:
  70             case atAverage:
  71                 // The mean-average division is done later
  72                 // when the Snmp::Pdu::fixAggregate() called
  73                 aggr += var;
  74                 break;
  75             case atMax:
  76                 if (var > aggr)
  77                     aggr.copyValue(var);
  78                 break;
  79             case atMin:
  80                 if (var < aggr)
  81                     aggr.copyValue(var);
  82                 break;
  83             default:
  84                 break;
  85             }
  86         }
  87     }
  88 }
  89
  90 void
  91 Snmp::Pdu::clear()
  92 {
  93     clearSystemOid();
  94     clearVars();
  95     init();
  96 }
  97
  98 void
  99 Snmp::Pdu::assign(const Pdu& pdu)
 100 {
 101     command = pdu.command;
 102     address.sin_addr.s_addr = pdu.address.sin_addr.s_addr;
 103     reqid = pdu.reqid;
 104     errstat = pdu.errstat;
 105     errindex = pdu.errindex;
 106     non_repeaters = pdu.non_repeaters;
 107     max_repetitions = pdu.max_repetitions;
 108     agent_addr.sin_addr.s_addr = pdu.agent_addr.sin_addr.s_addr;
 109     trap_type = pdu.trap_type;
 110     specific_type = pdu.specific_type;
 111     time = pdu.time;
 112     aggrCount = pdu.aggrCount;
 113     setSystemOid(pdu.getSystemOid());
 114     setVars(pdu.variables);
 115 }
 116
 117 void
 118 Snmp::Pdu::clearVars()
 119 {
 120     variable_list* var = variables;
 121     while (var != nullptr) {
 122         variable_list* tmp = var;
 123         var = var->next_variable;
 124         snmp_var_free(tmp);
 125     }
 126     variables = nullptr;
 127 }
 128
 129 void
 130 Snmp::Pdu::setVars(variable_list* vars)
 131 {
 132     clearVars();
 133     for (variable_list** p_var = &variables; vars != nullptr;
 134             vars = vars->next_variable, p_var = &(*p_var)->next_variable) {
 135         *p_var = new Var(static_cast<Var&>(*vars));
 136     }
 137 }
 138
 139 void
 140 Snmp::Pdu::clearSystemOid()
 141 {
 142     if (enterprise != nullptr) {
 143         xfree(enterprise);
 144         enterprise = nullptr;
 145     }
 146     enterprise_length = 0;
 147 }
 148
 149 Range<const oid*>
 150 Snmp::Pdu::getSystemOid() const
 151 {
 152     return Range<const oid*>(enterprise, enterprise + enterprise_length);
 153 }
 154
 155 void
 156 Snmp::Pdu::setSystemOid(const Range<const oid*>& systemOid)
 157 {
 158     clearSystemOid();
 159     if (systemOid.start != NULL && systemOid.size() != 0) {
 160         enterprise_length = systemOid.size();
 161         enterprise = static_cast<oid*>(xmalloc(enterprise_length * sizeof(oid)));
 162         std::copy(systemOid.start, systemOid.end, enterprise);
 163     }
 164 }
 165
 166 void
 167 Snmp::Pdu::pack(Ipc::TypedMsgHdr& msg) const
 168 {
 169     msg.putPod(command);
 170     msg.putPod(address);
 171     msg.putPod(reqid);
 172     msg.putPod(errstat);
 173     msg.putPod(errindex);
 174     msg.putPod(non_repeaters);
 175     msg.putPod(max_repetitions);
 176     msg.putInt(enterprise_length);
 177     if (enterprise_length > 0) {
 178         Must(enterprise != nullptr);
 179         msg.putFixed(enterprise, enterprise_length * sizeof(oid));
 180     }
 181     msg.putPod(agent_addr);
 182     msg.putPod(trap_type);
 183     msg.putPod(specific_type);
 184     msg.putPod(time);
 185     msg.putInt(varCount());
 186     for (variable_list* var = variables; var != nullptr; var = var->next_variable)
 187         static_cast<Var*>(var)->pack(msg);
 188 }
 189
 190 void
 191 Snmp::Pdu::unpack(const Ipc::TypedMsgHdr& msg)
 192 {
 193     clear();
 194     msg.getPod(command);
 195     msg.getPod(address);
 196     msg.getPod(reqid);
 197     msg.getPod(errstat);
 198     msg.getPod(errindex);
 199     msg.getPod(non_repeaters);
 200     msg.getPod(max_repetitions);
 201     enterprise_length = msg.getInt();
 202     if (enterprise_length > 0) {
 203         enterprise = static_cast<oid*>(xmalloc(enterprise_length * sizeof(oid)));
 204         msg.getFixed(enterprise, enterprise_length * sizeof(oid));
 205     }
 206     msg.getPod(agent_addr);
 207     msg.getPod(trap_type);
 208     msg.getPod(specific_type);
 209     msg.getPod(time);
 210     int count = msg.getInt();
 211     for (variable_list** p_var = &variables; count > 0;
 212             p_var = &(*p_var)->next_variable, --count) {
 213         Var* var = new Var();
 214         var->unpack(msg);
 215         *p_var = var;
 216     }
 217 }
 218
 219 int
 220 Snmp::Pdu::varCount() const
 221 {
 222     int count = 0;
 223     for (variable_list* var = variables; var != nullptr; var = var->next_variable)
 224         ++count;
 225     return count;
 226 }
 227
 228 void
 229 Snmp::Pdu::fixAggregate()
 230 {
 231     if (aggrCount < 2)
 232         return;
 233     for (variable_list* p_aggr = variables; p_aggr != nullptr; p_aggr = p_aggr->next_variable) {
 234         Var& aggr = static_cast<Var&>(*p_aggr);
 235         if (snmpAggrType(aggr.name, aggr.name_length) == atAverage) {
 236             aggr /= aggrCount;
 237         }
 238     }
 239     aggrCount = 0;
 240 }
 241