?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cmd: remove sparc-only virtinfo
[unleashed.git] / usr / src / cmd / picl / plugins / sun4v / lib / snmp / debug.c
blob3a52599a63a973a793edfb8e4e7f69b4e9622301
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #ifdef SNMP_DEBUG
30
31 /*
32 * Debug routines
33 */
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <thread.h>
39 #include <synch.h>
40 #include <ctype.h>
41 #include <sys/types.h>
42 #include "asn1.h"
43 #include "pdu.h"
44 #include "snmplib.h"
45 #include "debug.h"
46
47 /*
48 * Buffer and line limits
49 */
50 #define SNMP_DBLOCK_SZ 4096
51 #define SNMP_DMAX_LINE 80
52 #define SNMP_NCHARS_IN_A_ROW 16
53
54 /*
55 * Debug flags
56 */
57 #define SNMP_DEBUG_CMD 0x01
58 #define SNMP_DEBUG_VAR 0x02
59 #define SNMP_DEBUG_PDU 0x04
60 #define SNMP_DEBUG_ASN 0x08
61 #define SNMP_DEBUG_PKT 0x10
62 #define SNMP_DEBUG_IO 0x20
63
64 #define SNMP_DEBUG_DEFAULT 0x15 /* cmd, pdu, pkt */
65 #define SNMP_DEBUG_EXTENDED 0x35 /* cmd, pdu, pkt, io */
66 #define SNMP_DEBUG_ALL 0x3f
67
68 /*
69 * Formatting aids
70 */
71 #define SNMP_DCMD_INDENT 2
72 #define SNMP_DVAR_INDENT 4
73 #define SNMP_DPDU_INDENT 6
74 #define SNMP_DASN_INDENT 8
75 #define SNMP_DPKT_INDENT 10
76 #define SNMP_DIO_INDENT 12
77
78 #define SNMP_DHDR_PREFIX (const char *)" ___ "
79 #define SNMP_DHDR_SUFFIX (const char *)" ___"
80 #define SNMP_DTEXT_PREFIX (const char *)"| "
81
82 /*
83 * All debug vars are protected by a single lock
84 */
85 static mutex_t snmp_dbuf_lock; /* debug lock */
86 static uint16_t snmp_debug_flag = SNMP_DEBUG_EXTENDED; /* debug flags */
87 static char *snmp_dbuf = NULL; /* the debug buffer */
88 static char *snmp_dbuf_curp = NULL; /* current dbuf index */
89 static char *snmp_dbuf_tail = NULL; /* current dbuf tail */
90 static int snmp_dbuf_sz = 0; /* current dbuf size */
91 static int snmp_dbuf_overflow = 0; /* no more memory */
92 static char snmp_lbuf[SNMP_DMAX_LINE]; /* scratch space */
93
94 /*
95 * Key-to-string
96 */
97 typedef struct {
98 int key;
99 char *str;
100 } snmp_key_to_str_t;
101
102 static snmp_key_to_str_t snmp_cmds[] = {
103 { SNMP_MSG_GET, "SNMP_MSG_GET" },
104 { SNMP_MSG_GETNEXT, "SNMP_MSG_GETNEXT" },
105 { SNMP_MSG_RESPONSE, "SNMP_MSG_RESPONSE" },
106 { SNMP_MSG_SET, "SNMP_MSG_SET" },
107 { SNMP_MSG_TRAP, "SNMP_MSG_TRAP" },
108 { SNMP_MSG_GETBULK, "SNMP_MSG_GETBULK" },
109 { SNMP_MSG_INFORM, "SNMP_MSG_INFORM" },
110 { SNMP_MSG_TRAP2, "SNMP_MSG_TRAP2" },
111 { SNMP_MSG_REPORT, "SNMP_MSG_REPORT" }
112 };
113
114 static snmp_key_to_str_t snmp_vartypes[] = {
115 { ASN_BOOLEAN, "ASN_BOOLEAN" },
116 { ASN_INTEGER, "ASN_INTEGER" },
117 { ASN_BIT_STR, "ASN_BIT_STR" },
118 { ASN_OCTET_STR, "ASN_OCTET_STR" },
119 { ASN_NULL, "ASN_NULL" },
120 { ASN_OBJECT_ID, "ASN_OBJECT_ID" },
121 { ASN_SEQUENCE, "ASN_SEQUENCE" }
122 };
123
124 static snmp_key_to_str_t snmp_asnencodings[] = {
125 { SNMP_DASN_SEQUENCE, "ASN SEQUENCE" },
126 { SNMP_DASN_LENGTH, "ASN LENGTH" },
127 { SNMP_DASN_INT, "ASN INT" },
128 { SNMP_DASN_OCTET_STR, "ASN OCTET STR" },
129 { SNMP_DASN_OID, "ASN OBJECT ID" },
130 { SNMP_DASN_NULL, "ASN NULL" }
131 };
132
133 static char *debug_tags[] = {
134 "SNMP Command Request",
135 "Null Var",
136 "Response Var",
137 "Request PDU",
138 "Response PDU",
139 "Request Packet",
140 "Response Packet",
141 "WRITE",
142 "IOCTL",
143 "READ",
144 "SENDTO",
145 "RECVFROM"
146 };
147 static const int n_tags = sizeof (debug_tags) / sizeof (char *);
148
149 /*
150 * Helpers
151 */
152 static char *snmp_cmdstr_lookup(int cmd);
153 static char *snmp_vtypestr_lookup(int vtype);
154 static char *snmp_asnencoding_lookup(int asnkey);
155 static void snmp_get_dumpchars(uchar_t *abuf, uchar_t *p, int nchars);
156 static void snmp_log_append(char *bufp);
157 static void snmp_dbuf_realloc(void);
158
159 void
160 snmp_debug_init(void)
161 {
162 (void) mutex_init(&snmp_dbuf_lock, USYNC_THREAD, NULL);
163
164 (void) mutex_lock(&snmp_dbuf_lock);
165 snmp_dbuf_realloc();
166 if (snmp_dbuf == NULL)
167 snmp_debug_flag = 0; /* really tragic */
168 (void) mutex_unlock(&snmp_dbuf_lock);
169 }
170
171 void
172 snmp_log_cmd(uint_t tag, int cmd, int n_oids, char *oidstr, int row)
173 {
174 char *cmdstr;
175 int i;
176
177 if (oidstr == NULL)
178 return;
179
180 (void) mutex_lock(&snmp_dbuf_lock);
181
182 if ((snmp_debug_flag & SNMP_DEBUG_CMD) == 0) {
183 (void) mutex_unlock(&snmp_dbuf_lock);
184 return;
185 }
186
187 snmp_log_append("\n");
188
189 if (tag < n_tags) {
190 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
191 SNMP_DCMD_INDENT, ' ', SNMP_DHDR_PREFIX,
192 debug_tags[tag], SNMP_DHDR_SUFFIX);
193 snmp_log_append(snmp_lbuf);
194 }
195
196 if ((cmdstr = snmp_cmdstr_lookup(cmd)) == NULL) {
197 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sCMD=%#x\n",
198 SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX, cmd);
199 } else {
200 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s\n",
201 SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX, cmdstr);
202 }
203 snmp_log_append(snmp_lbuf);
204
205 for (i = 0; i < n_oids; i++) {
206 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s %s.%d\n",
207 SNMP_DCMD_INDENT, ' ', SNMP_DTEXT_PREFIX,
208 oidstr, row);
209 snmp_log_append(snmp_lbuf);
210
211 oidstr += strlen(oidstr) + 1;
212 }
213
214 (void) mutex_unlock(&snmp_dbuf_lock);
215 }
216
217 void
218 snmp_log_var(uint_t tag, pdu_varlist_t *vp)
219 {
220 char *vts;
221
222 if (vp == NULL)
223 return;
224
225 (void) mutex_lock(&snmp_dbuf_lock);
226
227 if ((snmp_debug_flag & SNMP_DEBUG_VAR) == 0) {
228 (void) mutex_unlock(&snmp_dbuf_lock);
229 return;
230 }
231
232 snmp_log_append("\n");
233
234 if (tag < n_tags) {
235 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
236 SNMP_DVAR_INDENT, ' ', SNMP_DHDR_PREFIX,
237 debug_tags[tag], SNMP_DHDR_SUFFIX);
238 snmp_log_append(snmp_lbuf);
239 }
240
241 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%snextvar = %#x\n",
242 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->nextvar);
243 snmp_log_append(snmp_lbuf);
244
245 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sname = %#x\n",
246 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->name);
247 snmp_log_append(snmp_lbuf);
248
249 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sname_len = %u\n",
250 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->name_len);
251 snmp_log_append(snmp_lbuf);
252
253 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sval.ptr = %#x\n",
254 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->val.str);
255 snmp_log_append(snmp_lbuf);
256
257 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sval_len = %u\n",
258 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->val_len);
259 snmp_log_append(snmp_lbuf);
260
261 if ((vts = snmp_vtypestr_lookup(vp->type)) == NULL) {
262 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%stype = %#x\n",
263 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vp->type);
264 } else {
265 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%stype = %s\n",
266 SNMP_DVAR_INDENT, ' ', SNMP_DTEXT_PREFIX, vts);
267 }
268 snmp_log_append(snmp_lbuf);
269
270 (void) mutex_unlock(&snmp_dbuf_lock);
271 }
272
273 void
274 snmp_log_pdu(uint_t tag, snmp_pdu_t *pdu)
275 {
276 char *cmdstr;
277
278 if (pdu == NULL)
279 return;
280
281 (void) mutex_lock(&snmp_dbuf_lock);
282
283 if ((snmp_debug_flag & SNMP_DEBUG_PDU) == 0) {
284 (void) mutex_unlock(&snmp_dbuf_lock);
285 return;
286 }
287
288 snmp_log_append("\n");
289
290 if (tag < n_tags) {
291 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
292 SNMP_DPDU_INDENT, ' ', SNMP_DHDR_PREFIX,
293 debug_tags[tag], SNMP_DHDR_SUFFIX);
294 snmp_log_append(snmp_lbuf);
295 }
296
297 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sversion = %d\n",
298 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->version);
299 snmp_log_append(snmp_lbuf);
300
301 if (pdu->community) {
302 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
303 "%*c%scommunity = %s\n", SNMP_DPDU_INDENT, ' ',
304 SNMP_DTEXT_PREFIX, pdu->community);
305 } else {
306 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
307 "%*c%scommunity = %#x\n", SNMP_DPDU_INDENT, ' ',
308 SNMP_DTEXT_PREFIX, pdu->community);
309 }
310 snmp_log_append(snmp_lbuf);
311
312 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%scommunity_len = %u\n",
313 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->community_len);
314 snmp_log_append(snmp_lbuf);
315
316 if ((cmdstr = snmp_cmdstr_lookup(pdu->command)) == NULL) {
317 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
318 "%*c%scommand = %#x\n", SNMP_DPDU_INDENT, ' ',
319 SNMP_DTEXT_PREFIX, pdu->command);
320 } else {
321 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
322 "%*c%scommand = %s\n", SNMP_DPDU_INDENT, ' ',
323 SNMP_DTEXT_PREFIX, cmdstr);
324 }
325 snmp_log_append(snmp_lbuf);
326
327 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreqid = %d\n",
328 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reqid);
329 snmp_log_append(snmp_lbuf);
330
331 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
332 "%*c%serrstat = %#x (non-repeaters)\n", SNMP_DPDU_INDENT, ' ',
333 SNMP_DTEXT_PREFIX, pdu->errstat);
334 snmp_log_append(snmp_lbuf);
335
336 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
337 "%*c%serrindex = %u (max-reps)\n", SNMP_DPDU_INDENT, ' ',
338 SNMP_DTEXT_PREFIX, pdu->errindex);
339 snmp_log_append(snmp_lbuf);
340
341 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%svars = %#x\n",
342 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->vars);
343 snmp_log_append(snmp_lbuf);
344
345 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreq_pkt = %#x\n",
346 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->req_pkt);
347 snmp_log_append(snmp_lbuf);
348
349 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreq_pktsz = %u\n",
350 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->req_pktsz);
351 snmp_log_append(snmp_lbuf);
352
353 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreply_pkt = %#x\n",
354 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reply_pkt);
355 snmp_log_append(snmp_lbuf);
356
357 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sreply_pktsz = %u\n",
358 SNMP_DPDU_INDENT, ' ', SNMP_DTEXT_PREFIX, pdu->reply_pktsz);
359 snmp_log_append(snmp_lbuf);
360
361 snmp_log_append("\n");
362
363 (void) mutex_unlock(&snmp_dbuf_lock);
364 }
365
366 void
367 snmp_log_asn(int key, uchar_t *pkt, size_t pktsz)
368 {
369 char *p, *asnstr;
370 int i, len;
371 size_t nrows, nrem;
372
373 if (pkt == NULL)
374 return;
375
376 (void) mutex_lock(&snmp_dbuf_lock);
377
378 if ((snmp_debug_flag & SNMP_DEBUG_ASN) == 0) {
379 (void) mutex_unlock(&snmp_dbuf_lock);
380 return;
381 }
382
383 if ((asnstr = snmp_asnencoding_lookup(key)) == NULL) {
384 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%sASNKEY=%#x\n",
385 SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX, key);
386 } else {
387 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s\n",
388 SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX, asnstr);
389 }
390 snmp_log_append(snmp_lbuf);
391
392 nrows = pktsz / 16;
393 for (i = 0; i < nrows; i++) {
394 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s "
395 "%02x %02x %02x %02x %02x %02x %02x %02x "
396 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
397 SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX,
398 pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5],
399 pkt[6], pkt[7], pkt[8], pkt[9], pkt[10], pkt[11],
400 pkt[12], pkt[13], pkt[14], pkt[15]);
401
402 pkt += 16;
403 snmp_log_append(snmp_lbuf);
404 }
405
406 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s ",
407 SNMP_DASN_INDENT, ' ', SNMP_DTEXT_PREFIX);
408
409 p = snmp_lbuf + SNMP_DASN_INDENT + strlen(SNMP_DTEXT_PREFIX) + 1;
410 len = SNMP_DMAX_LINE - SNMP_DASN_INDENT - strlen(SNMP_DTEXT_PREFIX) - 1;
411
412 nrem = pktsz % 16;
413 for (i = 0; i < nrem; i++) {
414 (void) snprintf(p, len, " %02x", pkt[i]);
415
416 p += 3;
417 len -= 3;
418 }
419 (void) snprintf(p, len, "\n");
420 snmp_log_append(snmp_lbuf);
421
422 (void) mutex_unlock(&snmp_dbuf_lock);
423 }
424
425 void
426 snmp_log_pkt(uint_t tag, uchar_t *pkt, size_t pktsz)
427 {
428 uchar_t ascii[SNMP_NCHARS_IN_A_ROW + 1];
429 uchar_t *p = pkt;
430 char *bufp;
431 int nrows, nrem;
432 int i, len;
433
434 if (pkt == NULL)
435 return;
436
437 (void) mutex_lock(&snmp_dbuf_lock);
438
439 if ((snmp_debug_flag & SNMP_DEBUG_PKT) == 0) {
440 (void) mutex_unlock(&snmp_dbuf_lock);
441 return;
442 }
443
444 snmp_log_append("\n");
445
446 if (tag < n_tags) {
447 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s%s%s\n",
448 SNMP_DPKT_INDENT, ' ',
449 SNMP_DHDR_PREFIX, debug_tags[tag], SNMP_DHDR_SUFFIX);
450 snmp_log_append(snmp_lbuf);
451 }
452
453 nrows = pktsz / SNMP_NCHARS_IN_A_ROW;
454 nrem = pktsz % SNMP_NCHARS_IN_A_ROW;
455
456 for (i = 0; i < nrows; i++) {
457 snmp_get_dumpchars(ascii, p, SNMP_NCHARS_IN_A_ROW);
458 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s"
459 "%02x %02x %02x %02x %02x %02x %02x %02x "
460 "%02x %02x %02x %02x %02x %02x %02x %02x "
461 "%s\n",
462 SNMP_DPKT_INDENT, ' ', SNMP_DTEXT_PREFIX,
463 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
464 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15],
465 ascii);
466 p += 16;
467
468 snmp_log_append(snmp_lbuf);
469 }
470
471 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE, "%*c%s",
472 SNMP_DPKT_INDENT, ' ', SNMP_DTEXT_PREFIX);
473
474 snmp_get_dumpchars(ascii, p, nrem);
475
476 bufp = snmp_lbuf + SNMP_DPKT_INDENT + strlen(SNMP_DTEXT_PREFIX);
477 len = SNMP_DMAX_LINE - SNMP_DPKT_INDENT + strlen(SNMP_DTEXT_PREFIX);
478 for (i = 0; i < 16; i++) {
479 if (i < nrem)
480 (void) snprintf(bufp, len, "%02x ", p[i]);
481 else
482 (void) snprintf(bufp, len, " ");
483
484 bufp += 3;
485 len -= 3;
486 }
487 (void) snprintf(bufp, len, "%s\n", ascii);
488 snmp_log_append(snmp_lbuf);
489
490 (void) mutex_unlock(&snmp_dbuf_lock);
491 }
492
493 void
494 snmp_log_io(uint_t tag, int a1, uint_t a2, uint_t a3)
495 {
496 (void) mutex_lock(&snmp_dbuf_lock);
497
498 if ((snmp_debug_flag & SNMP_DEBUG_IO) == 0) {
499 (void) mutex_unlock(&snmp_dbuf_lock);
500 return;
501 }
502
503 snmp_log_append("\n");
504
505 if (tag < n_tags) {
506 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
507 "%*c%s%s(%d, %#x, %#x)\n", SNMP_DIO_INDENT, ' ',
508 SNMP_DTEXT_PREFIX, debug_tags[tag], a1, a2, a3);
509 } else {
510 (void) snprintf(snmp_lbuf, SNMP_DMAX_LINE,
511 "%*c%s%#x(%d, %#x, %#x)\n", SNMP_DIO_INDENT, ' ',
512 SNMP_DTEXT_PREFIX, tag, a1, a2, a3);
513 }
514
515 snmp_log_append(snmp_lbuf);
516
517 (void) mutex_unlock(&snmp_dbuf_lock);
518 }
519
520 static char *
521 snmp_cmdstr_lookup(int cmd)
522 {
523 int nelem = sizeof (snmp_cmds) / sizeof (snmp_key_to_str_t);
524 int i;
525
526 for (i = 0; i < nelem; i++) {
527 if (snmp_cmds[i].key == cmd)
528 return (snmp_cmds[i].str);
529 }
530
531 return (NULL);
532 }
533
534 static char *
535 snmp_vtypestr_lookup(int vtype)
536 {
537 int nelem = sizeof (snmp_vartypes) / sizeof (snmp_key_to_str_t);
538 int i;
539
540 for (i = 0; i < nelem; i++) {
541 if (snmp_vartypes[i].key == vtype)
542 return (snmp_vartypes[i].str);
543 }
544
545 return (NULL);
546 }
547
548 static char *
549 snmp_asnencoding_lookup(int asnkey)
550 {
551 int nelem = sizeof (snmp_asnencodings) / sizeof (snmp_key_to_str_t);
552 int i;
553
554 for (i = 0; i < nelem; i++) {
555 if (snmp_asnencodings[i].key == asnkey)
556 return (snmp_asnencodings[i].str);
557 }
558
559 return (NULL);
560 }
561
562 static void
563 snmp_get_dumpchars(uchar_t *abuf, uchar_t *p, int nchars)
564 {
565 int i;
566
567 if (nchars > SNMP_NCHARS_IN_A_ROW)
568 nchars = SNMP_NCHARS_IN_A_ROW;
569
570 abuf[nchars] = 0;
571 for (i = 0; i < nchars; i++)
572 abuf[i] = isprint(p[i]) ? p[i] : '.';
573 }
574
575 static void
576 snmp_log_append(char *bufp)
577 {
578 int len;
579
580 len = strlen(bufp);
581 if ((snmp_dbuf_curp + len) >= snmp_dbuf_tail)
582 snmp_dbuf_realloc();
583
584 (void) strcpy(snmp_dbuf_curp, bufp);
585
586 snmp_dbuf_curp += len;
587 }
588
589 static void
590 snmp_dbuf_realloc(void)
591 {
592 char *p;
593 size_t offset = 0;
594 size_t count;
595
596 count = snmp_dbuf_sz + SNMP_DBLOCK_SZ;
597 if ((p = (char *)calloc(count, 1)) == NULL) {
598 snmp_dbuf_overflow++;
599 snmp_dbuf_curp = snmp_dbuf;
600 return;
601 }
602
603 if (snmp_dbuf) {
604 offset = snmp_dbuf_curp - snmp_dbuf;
605 (void) memcpy(p, snmp_dbuf, snmp_dbuf_sz);
606 free(snmp_dbuf);
607 }
608
609 snmp_dbuf = p;
610 snmp_dbuf_sz += SNMP_DBLOCK_SZ;
611
612 snmp_dbuf_curp = snmp_dbuf + offset;
613 snmp_dbuf_tail = snmp_dbuf + snmp_dbuf_sz;
614 }
615
616 #endif
Unleashed OS