Var.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2018 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 "Debug.h"
14 #include "ipc/TypedMsgHdr.h"
15 #include "snmp/Var.h"
16 #include "tools.h"
17 
18 #include <algorithm>
19 
21 {
22  init();
23 }
24 
25 Snmp::Var::Var(const Var& var)
26 {
27  init();
28  assign(var);
29 }
30 
32 {
33  clear();
34 }
35 
36 Snmp::Var&
38 {
39  clear();
40  assign(var);
41  return *this;
42 }
43 
44 void
46 {
47  memset(static_cast<variable_list *>(this), 0, sizeof(variable_list));
48 }
49 
50 Snmp::Var&
52 {
53  switch (type) {
54  case SMI_INTEGER:
55  setInt(asInt() + var.asInt());
56  break;
57  case SMI_GAUGE32:
58  setGauge(asGauge() + var.asGauge());
59  break;
60  case SMI_COUNTER32:
61  setCounter(asCounter() + var.asCounter());
62  break;
63  case SMI_COUNTER64:
64  setCounter64(asCounter64() + var.asCounter64());
65  break;
66  case SMI_TIMETICKS:
67  setTimeTicks(asTimeTicks() + var.asTimeTicks());
68  break;
69  default:
70  debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
71  throw TexcHere("Unsupported type");
72  break;
73  }
74  return *this;
75 }
76 
77 Snmp::Var&
79 {
80  Must(num != 0);
81  switch (type) {
82  case SMI_INTEGER:
83  setInt(asInt() / num);
84  break;
85  case SMI_GAUGE32:
86  setGauge(asGauge() / num);
87  break;
88  case SMI_COUNTER32:
89  setCounter(asCounter() / num);
90  break;
91  case SMI_COUNTER64:
92  setCounter64(asCounter64() / num);
93  break;
94  case SMI_TIMETICKS:
95  setTimeTicks(asTimeTicks() / num);
96  break;
97  default:
98  debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
99  throw TexcHere("Unsupported type");
100  break;
101  }
102  return *this;
103 }
104 
105 bool
106 Snmp::Var::operator < (const Var& var) const
107 {
108  switch (type) {
109  case SMI_INTEGER:
110  return asInt() < var.asInt();
111  case SMI_GAUGE32:
112  return asGauge() < var.asGauge();
113  case SMI_COUNTER32:
114  return asCounter() < var.asCounter();
115  case SMI_COUNTER64:
116  return asCounter64() < var.asCounter64();
117  case SMI_TIMETICKS:
118  return asTimeTicks() < var.asTimeTicks();
119  default:
120  debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
121  throw TexcHere("Unsupported type");
122  break;
123  }
124  return false; // unreachable
125 }
126 
127 bool
128 Snmp::Var::operator > (const Var& var) const
129 {
130  switch (type) {
131  case SMI_INTEGER:
132  return asInt() > var.asInt();
133  case SMI_GAUGE32:
134  return asGauge() > var.asGauge();
135  case SMI_COUNTER32:
136  return asCounter() > var.asCounter();
137  case SMI_COUNTER64:
138  return asCounter64() > var.asCounter64();
139  case SMI_TIMETICKS:
140  return asTimeTicks() > var.asTimeTicks();
141  default:
142  debugs(49, DBG_CRITICAL, HERE << "Unsupported type: " << type);
143  throw TexcHere("Unsupported type");
144  break;
145  }
146  return false; // unreachable
147 }
148 
149 void
151 {
152  setName(var.getName());
153  copyValue(var);
154 }
155 
156 void
158 {
159  xfree(name);
160  name = nullptr;
161  name_length = 0;
162 }
163 
166 {
167  return Range<const oid*>(name, name + name_length);
168 }
169 
170 void
172 {
173  clearName();
174  if (aName.start != NULL && aName.size() != 0) {
175  name_length = aName.size();
176  name = static_cast<oid*>(xmalloc(name_length * sizeof(oid)));
177  std::copy(aName.start, aName.end, name);
178  }
179 }
180 
181 void
183 {
184  xfree(val.string);
185  val.string = nullptr;
186  val_len = 0;
187  type = 0;
188 }
189 
190 bool
192 {
193  return type == SMI_NULLOBJ;
194 }
195 
196 int
198 {
199  Must(type == SMI_INTEGER);
200  Must(val.integer != NULL && val_len == sizeof(int));
201  return *val.integer;
202 }
203 
204 unsigned int
206 {
207  Must(type == SMI_GAUGE32);
208  Must(val.integer != NULL && val_len == 4);
209  return *reinterpret_cast<unsigned int*>(val.integer);
210 }
211 
212 int
214 {
215  Must(type == SMI_COUNTER32);
216  Must(val.integer != NULL && val_len == 4);
217  return *reinterpret_cast<int*>(val.integer);
218 }
219 
220 long long int
222 {
223  Must(type == SMI_COUNTER64);
224  Must(val.integer != NULL && val_len == 8);
225  return *reinterpret_cast<long long int*>(val.integer);
226 }
227 
228 unsigned int
230 {
231  Must(type == SMI_TIMETICKS);
232  Must(val.integer != NULL && val_len == sizeof(unsigned int));
233  return *reinterpret_cast<unsigned int*>(val.integer);
234 }
235 
238 {
239  Must(type == SMI_OBJID);
240  Must(val_len % sizeof(oid) == 0);
241  int length = val_len / sizeof(oid);
242  Must(val.objid != NULL && length > 0);
243  return Range<const oid*>(val.objid, val.objid + length);
244 }
245 
248 {
249  Must(type == SMI_STRING);
250  Must(val.string != NULL && val_len > 0);
251  return Range<const u_char*>(val.string, val.string + val_len);
252 }
253 
254 void
256 {
257  setValue(&value, sizeof(value), SMI_INTEGER);
258 }
259 
260 void
262 {
263  setValue(&value, sizeof(value), SMI_COUNTER32);
264 }
265 
266 void
267 Snmp::Var::setGauge(unsigned int value)
268 {
269  setValue(&value, sizeof(value), SMI_GAUGE32);
270 }
271 
272 void
274 {
275  setValue(string.start, string.size(), SMI_STRING);
276 }
277 
278 void
280 {
281  setValue(object.start, object.size() * sizeof(oid), SMI_OBJID);
282 }
283 
284 void
285 Snmp::Var::setCounter64(long long int counter)
286 {
287  setValue(&counter, sizeof(counter), SMI_COUNTER64);
288 }
289 
290 void
291 Snmp::Var::setTimeTicks(unsigned int ticks)
292 {
293  setValue(&ticks, sizeof(ticks), SMI_TIMETICKS);
294 }
295 
296 void
298 {
299  setValue(var.val.string, var.val_len, var.type);
300 }
301 
302 void
303 Snmp::Var::setValue(const void* value, int length, int aType)
304 {
305  clearValue();
306  if (value != NULL) {
307  Must(length > 0 && aType > 0);
308  val.string = static_cast<u_char*>(xmalloc(length));
309  memcpy(val.string, value, length);
310  }
311  val_len = length;
312  type = aType;
313 }
314 
315 void
317 {
318  clearName();
319  clearValue();
320  init();
321 }
322 
323 void
325 {
326  msg.putInt(name_length);
327  if (name_length > 0) {
328  Must(name != NULL);
329  msg.putFixed(name, name_length * sizeof(oid));
330  }
331  msg.putPod(type);
332  msg.putPod(val_len);
333  if (val_len > 0) {
334  Must(val.string != NULL);
335  msg.putFixed(val.string, val_len);
336  }
337 }
338 
339 void
341 {
342  clearName();
343  clearValue();
344  name_length = msg.getInt();
345  Must(name_length >= 0);
346  if (name_length > 0) {
347  name = static_cast<oid*>(xmalloc(name_length * sizeof(oid)));
348  msg.getFixed(name, name_length * sizeof(oid));
349  }
350  msg.getPod(type);
351  val_len = msg.getInt();
352  Must(val_len >= 0);
353  if (val_len > 0) {
354  val.string = static_cast<u_char*>(xmalloc(val_len));
355  msg.getFixed(val.string, val_len);
356  }
357 }
358 
void clear()
clear all internal members
Definition: Var.cc:316
void init()
initialize members
Definition: Var.cc:45
~Var()
Definition: Var.cc:31
void unpack(const Ipc::TypedMsgHdr &msg)
restore struct from the message
Definition: Var.cc:340
void assign(const Var &var)
perform full assignment
Definition: Var.cc:150
static void copyValue(void *dst, const DB_ENTRY *src, size_t sz)
bool operator>(const Var &var) const
Definition: Var.cc:128
unsigned int asTimeTicks() const
returns variable value as time ticks
Definition: Var.cc:229
int type
Definition: errorpage.cc:78
#define SMI_STRING
Definition: snmp_vars.h:72
void putInt(int n)
store an integer
Definition: TypedMsgHdr.cc:126
void getPod(Pod &pod) const
load POD
Definition: TypedMsgHdr.h:50
int asCounter() const
returns variable value as Counter32
Definition: Var.cc:213
long long int asCounter64() const
returns variable value as Counter64
Definition: Var.cc:221
Range< const oid * > asObject() const
returns variable value as object oid
Definition: Var.cc:237
Range< const u_char * > asString() const
returns variable value as chars string
Definition: Var.cc:247
Definition: Range.h:18
void putPod(const Pod &pod)
store POD
Definition: TypedMsgHdr.h:52
#define Must(condition)
Like assert() but throws an exception instead of aborting the process.
Definition: TextException.h:69
void setString(const Range< const u_char * > &string)
assign string to variable
Definition: Var.cc:273
#define DBG_CRITICAL
Definition: Debug.h:45
void getFixed(void *raw, size_t size) const
always load size bytes
Definition: TypedMsgHdr.cc:158
S size() const
Definition: Range.h:61
void setTimeTicks(unsigned int ticks)
assign unsigned int (time) value to variable
Definition: Var.cc:291
u_char type
Definition: snmp_vars.h:48
unsigned int asGauge() const
returns variable value as unsigned int
Definition: Var.cc:205
void setCounter(int value)
assign Counter32 value to variable
Definition: Var.cc:261
#define SMI_INTEGER
Definition: snmp_vars.h:71
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Debug.h:124
void setName(const Range< const oid * > &aName)
set new variable name
Definition: Var.cc:171
union variable_list::@20 val
void setGauge(unsigned int value)
assign unsigned int value to variable
Definition: Var.cc:267
#define SMI_COUNTER64
Definition: snmp_vars.h:81
bool operator<(const Var &var) const
Definition: Var.cc:106
int asInt() const
returns variable value as integer
Definition: Var.cc:197
C start
Definition: Range.h:24
void clearValue()
clear .val member
Definition: Var.cc:182
void setInt(int value)
assign int value to variable
Definition: Var.cc:255
int getInt() const
load an integer
Definition: TypedMsgHdr.cc:118
C end
Definition: Range.h:25
void setCounter64(long long int counter)
assign Counter64 value to variable
Definition: Var.cc:285
std::ostream & HERE(std::ostream &s)
Definition: Debug.h:153
u_int oid
Definition: asn1.h:42
#define SMI_TIMETICKS
Definition: snmp_vars.h:79
Var()
Definition: Var.cc:20
#define xmalloc
void setObject(const Range< const oid * > &object)
assign object oid to variable
Definition: Var.cc:279
Definition: Var.h:23
struct msghdr with a known type, fixed-size I/O and control buffers
Definition: TypedMsgHdr.h:31
Var & operator=(const Var &var)
Definition: Var.cc:37
Range< const oid * > getName() const
returns variable name
Definition: Var.cc:165
#define SMI_COUNTER32
Definition: snmp_vars.h:76
void pack(Ipc::TypedMsgHdr &msg) const
prepare for sendmsg()
Definition: Var.cc:324
#define TexcHere(msg)
legacy convenience macro; it is not difficult to type Here() now
Definition: TextException.h:55
Var & operator+=(const Var &var)
Definition: Var.cc:51
Var & operator/=(int num)
Definition: Var.cc:78
bool isNull() const
Definition: Var.cc:191
#define xfree
#define SMI_NULLOBJ
Definition: snmp_vars.h:74
void setValue(const void *value, int length, int aType)
set new variable value
Definition: Var.cc:303
#define SMI_GAUGE32
Definition: snmp_vars.h:77
void clearName()
clear variable name
Definition: Var.cc:157
#define NULL
Definition: types.h:166
void putFixed(const void *raw, size_t size)
always store size bytes
Definition: TypedMsgHdr.cc:165
int size
Definition: ModDevPoll.cc:77
u_char * string
Definition: snmp_vars.h:51
#define SMI_OBJID
Definition: snmp_vars.h:73
void copyValue(const Var &var)
copy variable from another one
Definition: Var.cc:297

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors