1 /*
2 * SNMP functions for CUPS.
3 *
4 * Copyright © 2007-2019 by Apple Inc.
5 * Copyright © 2006-2007 by Easy Software Products, all rights reserved.
6 *
7 * Licensed under Apache License v2.0. See the file "LICENSE" for more
8 * information.
9 */
10
11 /*
12 * Include necessary headers.
13 */
14
15 #include "cups-private.h"
16 #include "snmp-private.h"
17 #include "debug-internal.h"
18 #ifdef HAVE_POLL
19 # include <poll.h>
20 #endif /* HAVE_POLL */
21
22
23 /*
24 * Local functions...
25 */
26
27 static void asn1_debug(const char *prefix, unsigned char *buffer,
28 size_t len, int indent);
29 static int asn1_decode_snmp(unsigned char *buffer, size_t len,
30 cups_snmp_t *packet);
31 static int asn1_encode_snmp(unsigned char *buffer, size_t len,
32 cups_snmp_t *packet);
33 static int asn1_get_integer(unsigned char **buffer,
34 unsigned char *bufend,
35 unsigned length);
36 static int asn1_get_oid(unsigned char **buffer,
37 unsigned char *bufend,
38 unsigned length, int *oid, int oidsize);
39 static int asn1_get_packed(unsigned char **buffer,
40 unsigned char *bufend);
41 static char *asn1_get_string(unsigned char **buffer,
42 unsigned char *bufend,
43 unsigned length, char *string,
44 size_t strsize);
45 static unsigned asn1_get_length(unsigned char **buffer,
46 unsigned char *bufend);
47 static int asn1_get_type(unsigned char **buffer,
48 unsigned char *bufend);
49 static void asn1_set_integer(unsigned char **buffer,
50 int integer);
51 static void asn1_set_length(unsigned char **buffer,
52 unsigned length);
53 static void asn1_set_oid(unsigned char **buffer,
54 const int *oid);
55 static void asn1_set_packed(unsigned char **buffer,
56 int integer);
57 static unsigned asn1_size_integer(int integer);
58 static unsigned asn1_size_length(unsigned length);
59 static unsigned asn1_size_oid(const int *oid);
60 static unsigned asn1_size_packed(int integer);
61 static void snmp_set_error(cups_snmp_t *packet,
62 const char *message);
63
64
65 /*
66 * '_cupsSNMPClose()' - Close a SNMP socket.
67 */
68
69 void
_cupsSNMPClose(int fd)70 _cupsSNMPClose(int fd) /* I - SNMP socket file descriptor */
71 {
72 DEBUG_printf(("4_cupsSNMPClose(fd=%d)", fd));
73
74 httpAddrClose(NULL, fd);
75 }
76
77
78 /*
79 * '_cupsSNMPCopyOID()' - Copy an OID.
80 *
81 * The array pointed to by "src" is terminated by the value -1.
82 */
83
84 int * /* O - New OID */
_cupsSNMPCopyOID(int * dst,const int * src,int dstsize)85 _cupsSNMPCopyOID(int *dst, /* I - Destination OID */
86 const int *src, /* I - Source OID */
87 int dstsize) /* I - Number of integers in dst */
88 {
89 int i; /* Looping var */
90
91
92 DEBUG_printf(("4_cupsSNMPCopyOID(dst=%p, src=%p, dstsize=%d)", dst, src,
93 dstsize));
94
95 for (i = 0, dstsize --; src[i] >= 0 && i < dstsize; i ++)
96 dst[i] = src[i];
97
98 dst[i] = -1;
99
100 return (dst);
101 }
102
103
104 /*
105 * '_cupsSNMPDefaultCommunity()' - Get the default SNMP community name.
106 *
107 * The default community name is the first community name found in the
108 * snmp.conf file. If no community name is defined there, "public" is used.
109 */
110
111 const char * /* O - Default community name */
_cupsSNMPDefaultCommunity(void)112 _cupsSNMPDefaultCommunity(void)
113 {
114 cups_file_t *fp; /* snmp.conf file */
115 char line[1024], /* Line from file */
116 *value; /* Value from file */
117 int linenum; /* Line number in file */
118 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
119
120
121 DEBUG_puts("4_cupsSNMPDefaultCommunity()");
122
123 if (!cg->snmp_community[0])
124 {
125 strlcpy(cg->snmp_community, "public", sizeof(cg->snmp_community));
126
127 snprintf(line, sizeof(line), "%s/snmp.conf", cg->cups_serverroot);
128 if ((fp = cupsFileOpen(line, "r")) != NULL)
129 {
130 linenum = 0;
131 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
132 if (!_cups_strcasecmp(line, "Community"))
133 {
134 if (value)
135 strlcpy(cg->snmp_community, value, sizeof(cg->snmp_community));
136 else
137 cg->snmp_community[0] = '\0';
138
139 break;
140 }
141
142 cupsFileClose(fp);
143 }
144 }
145
146 DEBUG_printf(("5_cupsSNMPDefaultCommunity: Returning \"%s\"",
147 cg->snmp_community));
148
149 return (cg->snmp_community);
150 }
151
152
153 /*
154 * '_cupsSNMPIsOID()' - Test whether a SNMP response contains the specified OID.
155 *
156 * The array pointed to by "oid" is terminated by the value -1.
157 */
158
159 int /* O - 1 if equal, 0 if not equal */
_cupsSNMPIsOID(cups_snmp_t * packet,const int * oid)160 _cupsSNMPIsOID(cups_snmp_t *packet, /* I - Response packet */
161 const int *oid) /* I - OID */
162 {
163 int i; /* Looping var */
164
165
166 /*
167 * Range check input...
168 */
169
170 DEBUG_printf(("4_cupsSNMPIsOID(packet=%p, oid=%p)", packet, oid));
171
172 if (!packet || !oid)
173 {
174 DEBUG_puts("5_cupsSNMPIsOID: Returning 0");
175
176 return (0);
177 }
178
179 /*
180 * Compare OIDs...
181 */
182
183 for (i = 0;
184 i < CUPS_SNMP_MAX_OID && oid[i] >= 0 && packet->object_name[i] >= 0;
185 i ++)
186 if (oid[i] != packet->object_name[i])
187 {
188 DEBUG_puts("5_cupsSNMPIsOID: Returning 0");
189
190 return (0);
191 }
192
193 DEBUG_printf(("5_cupsSNMPIsOID: Returning %d",
194 i < CUPS_SNMP_MAX_OID && oid[i] == packet->object_name[i]));
195
196 return (i < CUPS_SNMP_MAX_OID && oid[i] == packet->object_name[i]);
197 }
198
199
200 /*
201 * '_cupsSNMPIsOIDPrefixed()' - Test whether a SNMP response uses the specified
202 * OID prefix.
203 *
204 * The array pointed to by "prefix" is terminated by the value -1.
205 */
206
207 int /* O - 1 if prefixed, 0 if not prefixed */
_cupsSNMPIsOIDPrefixed(cups_snmp_t * packet,const int * prefix)208 _cupsSNMPIsOIDPrefixed(
209 cups_snmp_t *packet, /* I - Response packet */
210 const int *prefix) /* I - OID prefix */
211 {
212 int i; /* Looping var */
213
214
215 /*
216 * Range check input...
217 */
218
219 DEBUG_printf(("4_cupsSNMPIsOIDPrefixed(packet=%p, prefix=%p)", packet,
220 prefix));
221
222 if (!packet || !prefix)
223 {
224 DEBUG_puts("5_cupsSNMPIsOIDPrefixed: Returning 0");
225
226 return (0);
227 }
228
229 /*
230 * Compare OIDs...
231 */
232
233 for (i = 0;
234 i < CUPS_SNMP_MAX_OID && prefix[i] >= 0 && packet->object_name[i] >= 0;
235 i ++)
236 if (prefix[i] != packet->object_name[i])
237 {
238 DEBUG_puts("5_cupsSNMPIsOIDPrefixed: Returning 0");
239
240 return (0);
241 }
242
243 DEBUG_printf(("5_cupsSNMPIsOIDPrefixed: Returning %d",
244 i < CUPS_SNMP_MAX_OID));
245
246 return (i < CUPS_SNMP_MAX_OID);
247 }
248
249
250 /*
251 * '_cupsSNMPOIDToString()' - Convert an OID to a string.
252 */
253
254
255 char * /* O - New string or @code NULL@ on error */
_cupsSNMPOIDToString(const int * src,char * dst,size_t dstsize)256 _cupsSNMPOIDToString(const int *src, /* I - OID */
257 char *dst, /* I - String buffer */
258 size_t dstsize) /* I - Size of string buffer */
259 {
260 char *dstptr, /* Pointer into string buffer */
261 *dstend; /* End of string buffer */
262
263
264 DEBUG_printf(("4_cupsSNMPOIDToString(src=%p, dst=%p, dstsize=" CUPS_LLFMT ")",
265 src, dst, CUPS_LLCAST dstsize));
266
267 /*
268 * Range check input...
269 */
270
271 if (!src || !dst || dstsize < 4)
272 return (NULL);
273
274 /*
275 * Loop through the OID array and build a string...
276 */
277
278 for (dstptr = dst, dstend = dstptr + dstsize - 1;
279 *src >= 0 && dstptr < dstend;
280 src ++, dstptr += strlen(dstptr))
281 snprintf(dstptr, (size_t)(dstend - dstptr + 1), ".%d", *src);
282
283 if (*src >= 0)
284 return (NULL);
285 else
286 return (dst);
287 }
288
289
290 /*
291 * '_cupsSNMPOpen()' - Open a SNMP socket.
292 */
293
294 int /* O - SNMP socket file descriptor */
_cupsSNMPOpen(int family)295 _cupsSNMPOpen(int family) /* I - Address family - @code AF_INET@ or @code AF_INET6@ */
296 {
297 int fd; /* SNMP socket file descriptor */
298 int val; /* Socket option value */
299
300
301 /*
302 * Create the SNMP socket...
303 */
304
305 DEBUG_printf(("4_cupsSNMPOpen(family=%d)", family));
306
307 if ((fd = socket(family, SOCK_DGRAM, 0)) < 0)
308 {
309 DEBUG_printf(("5_cupsSNMPOpen: Returning -1 (%s)", strerror(errno)));
310
311 return (-1);
312 }
313
314 /*
315 * Set the "broadcast" flag...
316 */
317
318 val = 1;
319
320 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, CUPS_SOCAST &val, sizeof(val)))
321 {
322 DEBUG_printf(("5_cupsSNMPOpen: Returning -1 (%s)", strerror(errno)));
323
324 close(fd);
325
326 return (-1);
327 }
328
329 DEBUG_printf(("5_cupsSNMPOpen: Returning %d", fd));
330
331 return (fd);
332 }
333
334
335 /*
336 * '_cupsSNMPRead()' - Read and parse a SNMP response.
337 *
338 * If "timeout" is negative, @code _cupsSNMPRead@ will wait for a response
339 * indefinitely.
340 */
341
342 cups_snmp_t * /* O - SNMP packet or @code NULL@ if none */
_cupsSNMPRead(int fd,cups_snmp_t * packet,double timeout)343 _cupsSNMPRead(int fd, /* I - SNMP socket file descriptor */
344 cups_snmp_t *packet, /* I - SNMP packet buffer */
345 double timeout) /* I - Timeout in seconds */
346 {
347 unsigned char buffer[CUPS_SNMP_MAX_PACKET];
348 /* Data packet */
349 ssize_t bytes; /* Number of bytes received */
350 socklen_t addrlen; /* Source address length */
351 http_addr_t address; /* Source address */
352
353
354 /*
355 * Range check input...
356 */
357
358 DEBUG_printf(("4_cupsSNMPRead(fd=%d, packet=%p, timeout=%.1f)", fd, packet,
359 timeout));
360
361 if (fd < 0 || !packet)
362 {
363 DEBUG_puts("5_cupsSNMPRead: Returning NULL");
364
365 return (NULL);
366 }
367
368 /*
369 * Optionally wait for a response...
370 */
371
372 if (timeout >= 0.0)
373 {
374 int ready; /* Data ready on socket? */
375 #ifdef HAVE_POLL
376 struct pollfd pfd; /* Polled file descriptor */
377
378 pfd.fd = fd;
379 pfd.events = POLLIN;
380
381 while ((ready = poll(&pfd, 1, (int)(timeout * 1000.0))) < 0 &&
382 (errno == EINTR || errno == EAGAIN));
383
384 #else
385 fd_set input_set; /* select() input set */
386 struct timeval stimeout; /* select() timeout */
387
388 do
389 {
390 FD_ZERO(&input_set);
391 FD_SET(fd, &input_set);
392
393 stimeout.tv_sec = (int)timeout;
394 stimeout.tv_usec = (int)((timeout - stimeout.tv_sec) * 1000000);
395
396 ready = select(fd + 1, &input_set, NULL, NULL, &stimeout);
397 }
398 # ifdef _WIN32
399 while (ready < 0 && WSAGetLastError() == WSAEINTR);
400 # else
401 while (ready < 0 && (errno == EINTR || errno == EAGAIN));
402 # endif /* _WIN32 */
403 #endif /* HAVE_POLL */
404
405 /*
406 * If we don't have any data ready, return right away...
407 */
408
409 if (ready <= 0)
410 {
411 DEBUG_puts("5_cupsSNMPRead: Returning NULL (timeout)");
412
413 return (NULL);
414 }
415 }
416
417 /*
418 * Read the response data...
419 */
420
421 addrlen = sizeof(address);
422
423 if ((bytes = recvfrom(fd, buffer, sizeof(buffer), 0, (void *)&address,
424 &addrlen)) < 0)
425 {
426 DEBUG_printf(("5_cupsSNMPRead: Returning NULL (%s)", strerror(errno)));
427
428 return (NULL);
429 }
430
431 /*
432 * Look for the response status code in the SNMP message header...
433 */
434
435 asn1_debug("DEBUG: IN ", buffer, (size_t)bytes, 0);
436
437 asn1_decode_snmp(buffer, (size_t)bytes, packet);
438
439 memcpy(&(packet->address), &address, sizeof(packet->address));
440
441 /*
442 * Return decoded data packet...
443 */
444
445 DEBUG_puts("5_cupsSNMPRead: Returning packet");
446
447 return (packet);
448 }
449
450
451 /*
452 * '_cupsSNMPSetDebug()' - Enable/disable debug logging to stderr.
453 */
454
455 void
_cupsSNMPSetDebug(int level)456 _cupsSNMPSetDebug(int level) /* I - 1 to enable debug output, 0 otherwise */
457 {
458 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
459
460
461 DEBUG_printf(("4_cupsSNMPSetDebug(level=%d)", level));
462
463 cg->snmp_debug = level;
464 }
465
466
467 /*
468 * '_cupsSNMPStringToOID()' - Convert a numeric OID string to an OID array.
469 *
470 * This function converts a string of the form ".N.N.N.N.N" to the
471 * corresponding OID array terminated by -1.
472 *
473 * @code NULL@ is returned if the array is not large enough or the string is
474 * not a valid OID number.
475 */
476
477 int * /* O - Pointer to OID array or @code NULL@ on error */
_cupsSNMPStringToOID(const char * src,int * dst,int dstsize)478 _cupsSNMPStringToOID(const char *src, /* I - OID string */
479 int *dst, /* I - OID array */
480 int dstsize)/* I - Number of integers in OID array */
481 {
482 int *dstptr, /* Pointer into OID array */
483 *dstend; /* End of OID array */
484
485
486 DEBUG_printf(("4_cupsSNMPStringToOID(src=\"%s\", dst=%p, dstsize=%d)",
487 src, dst, dstsize));
488
489 /*
490 * Range check input...
491 */
492
493 if (!src || !dst || dstsize < 2)
494 return (NULL);
495
496 /*
497 * Skip leading "."...
498 */
499
500 if (*src == '.')
501 src ++;
502
503 /*
504 * Loop to the end of the string...
505 */
506
507 for (dstend = dst + dstsize - 1, dstptr = dst, *dstptr = 0;
508 *src && dstptr < dstend;
509 src ++)
510 {
511 if (*src == '.')
512 {
513 dstptr ++;
514 *dstptr = 0;
515 }
516 else if (isdigit(*src & 255))
517 *dstptr = *dstptr * 10 + *src - '0';
518 else
519 break;
520 }
521
522 if (*src)
523 return (NULL);
524
525 /*
526 * Terminate the end of the OID array and return...
527 */
528
529 dstptr[1] = -1;
530
531 return (dst);
532 }
533
534
535 /*
536 * '_cupsSNMPWalk()' - Enumerate a group of OIDs.
537 *
538 * This function queries all of the OIDs with the specified OID prefix,
539 * calling the "cb" function for every response that is received.
540 *
541 * The array pointed to by "prefix" is terminated by the value -1.
542 *
543 * If "timeout" is negative, @code _cupsSNMPWalk@ will wait for a response
544 * indefinitely.
545 */
546
547 int /* O - Number of OIDs found or -1 on error */
_cupsSNMPWalk(int fd,http_addr_t * address,int version,const char * community,const int * prefix,double timeout,cups_snmp_cb_t cb,void * data)548 _cupsSNMPWalk(int fd, /* I - SNMP socket */
549 http_addr_t *address, /* I - Address to query */
550 int version, /* I - SNMP version */
551 const char *community,/* I - Community name */
552 const int *prefix, /* I - OID prefix */
553 double timeout, /* I - Timeout for each response in seconds */
554 cups_snmp_cb_t cb, /* I - Function to call for each response */
555 void *data) /* I - User data pointer that is passed to the callback function */
556 {
557 int count = 0; /* Number of OIDs found */
558 unsigned request_id = 0; /* Current request ID */
559 cups_snmp_t packet; /* Current response packet */
560 int lastoid[CUPS_SNMP_MAX_OID];
561 /* Last OID we got */
562
563
564 /*
565 * Range check input...
566 */
567
568 DEBUG_printf(("4_cupsSNMPWalk(fd=%d, address=%p, version=%d, "
569 "community=\"%s\", prefix=%p, timeout=%.1f, cb=%p, data=%p)",
570 fd, address, version, community, prefix, timeout, cb, data));
571
572 if (fd < 0 || !address || version != CUPS_SNMP_VERSION_1 || !community ||
573 !prefix || !cb)
574 {
575 DEBUG_puts("5_cupsSNMPWalk: Returning -1");
576
577 return (-1);
578 }
579
580 /*
581 * Copy the OID prefix and then loop until we have no more OIDs...
582 */
583
584 _cupsSNMPCopyOID(packet.object_name, prefix, CUPS_SNMP_MAX_OID);
585 lastoid[0] = -1;
586
587 for (;;)
588 {
589 request_id ++;
590
591 if (!_cupsSNMPWrite(fd, address, version, community,
592 CUPS_ASN1_GET_NEXT_REQUEST, request_id,
593 packet.object_name))
594 {
595 DEBUG_puts("5_cupsSNMPWalk: Returning -1");
596
597 return (-1);
598 }
599
600 if (!_cupsSNMPRead(fd, &packet, timeout))
601 {
602 DEBUG_puts("5_cupsSNMPWalk: Returning -1");
603
604 return (-1);
605 }
606
607 if (!_cupsSNMPIsOIDPrefixed(&packet, prefix) ||
608 _cupsSNMPIsOID(&packet, lastoid))
609 {
610 DEBUG_printf(("5_cupsSNMPWalk: Returning %d", count));
611
612 return (count);
613 }
614
615 if (packet.error || packet.error_status)
616 {
617 DEBUG_printf(("5_cupsSNMPWalk: Returning %d", count > 0 ? count : -1));
618
619 return (count > 0 ? count : -1);
620 }
621
622 _cupsSNMPCopyOID(lastoid, packet.object_name, CUPS_SNMP_MAX_OID);
623
624 count ++;
625
626 (*cb)(&packet, data);
627 }
628 }
629
630
631 /*
632 * '_cupsSNMPWrite()' - Send an SNMP query packet.
633 *
634 * The array pointed to by "oid" is terminated by the value -1.
635 */
636
637 int /* O - 1 on success, 0 on error */
_cupsSNMPWrite(int fd,http_addr_t * address,int version,const char * community,cups_asn1_t request_type,const unsigned request_id,const int * oid)638 _cupsSNMPWrite(
639 int fd, /* I - SNMP socket */
640 http_addr_t *address, /* I - Address to send to */
641 int version, /* I - SNMP version */
642 const char *community, /* I - Community name */
643 cups_asn1_t request_type, /* I - Request type */
644 const unsigned request_id, /* I - Request ID */
645 const int *oid) /* I - OID */
646 {
647 int i; /* Looping var */
648 cups_snmp_t packet; /* SNMP message packet */
649 unsigned char buffer[CUPS_SNMP_MAX_PACKET];
650 /* SNMP message buffer */
651 ssize_t bytes; /* Size of message */
652 http_addr_t temp; /* Copy of address */
653
654
655 /*
656 * Range check input...
657 */
658
659 DEBUG_printf(("4_cupsSNMPWrite(fd=%d, address=%p, version=%d, "
660 "community=\"%s\", request_type=%d, request_id=%u, oid=%p)",
661 fd, address, version, community, request_type, request_id, oid));
662
663 if (fd < 0 || !address || version != CUPS_SNMP_VERSION_1 || !community ||
664 (request_type != CUPS_ASN1_GET_REQUEST &&
665 request_type != CUPS_ASN1_GET_NEXT_REQUEST) || request_id < 1 || !oid)
666 {
667 DEBUG_puts("5_cupsSNMPWrite: Returning 0 (bad arguments)");
668
669 return (0);
670 }
671
672 /*
673 * Create the SNMP message...
674 */
675
676 memset(&packet, 0, sizeof(packet));
677
678 packet.version = version;
679 packet.request_type = request_type;
680 packet.request_id = request_id;
681 packet.object_type = CUPS_ASN1_NULL_VALUE;
682
683 strlcpy(packet.community, community, sizeof(packet.community));
684
685 for (i = 0; oid[i] >= 0 && i < (CUPS_SNMP_MAX_OID - 1); i ++)
686 packet.object_name[i] = oid[i];
687 packet.object_name[i] = -1;
688
689 if (oid[i] >= 0)
690 {
691 DEBUG_puts("5_cupsSNMPWrite: Returning 0 (OID too big)");
692
693 errno = E2BIG;
694 return (0);
695 }
696
697 bytes = asn1_encode_snmp(buffer, sizeof(buffer), &packet);
698
699 if (bytes < 0)
700 {
701 DEBUG_puts("5_cupsSNMPWrite: Returning 0 (request too big)");
702
703 errno = E2BIG;
704 return (0);
705 }
706
707 asn1_debug("DEBUG: OUT ", buffer, (size_t)bytes, 0);
708
709 /*
710 * Send the message...
711 */
712
713 temp = *address;
714
715 _httpAddrSetPort(&temp, CUPS_SNMP_PORT);
716
717 return (sendto(fd, buffer, (size_t)bytes, 0, (void *)&temp, (socklen_t)httpAddrLength(&temp)) == bytes);
718 }
719
720
721 /*
722 * 'asn1_debug()' - Decode an ASN1-encoded message.
723 */
724
725 static void
asn1_debug(const char * prefix,unsigned char * buffer,size_t len,int indent)726 asn1_debug(const char *prefix, /* I - Prefix string */
727 unsigned char *buffer, /* I - Buffer */
728 size_t len, /* I - Length of buffer */
729 int indent) /* I - Indentation */
730 {
731 size_t i; /* Looping var */
732 unsigned char *bufend; /* End of buffer */
733 int integer; /* Number value */
734 int oid[CUPS_SNMP_MAX_OID]; /* OID value */
735 char string[CUPS_SNMP_MAX_STRING];
736 /* String value */
737 unsigned char value_type; /* Type of value */
738 unsigned value_length; /* Length of value */
739 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
740
741
742 #ifdef __clang_analyzer__ /* Suppress bogus clang error */
743 memset(string, 0, sizeof(string));
744 #endif /* __clang_analyzer__ */
745
746 if (cg->snmp_debug <= 0)
747 return;
748
749 if (cg->snmp_debug > 1 && indent == 0)
750 {
751 /*
752 * Do a hex dump of the packet...
753 */
754
755 size_t j;
756
757 fprintf(stderr, "%sHex Dump (%d bytes):\n", prefix, (int)len);
758
759 for (i = 0; i < len; i += 16)
760 {
761 fprintf(stderr, "%s%04x:", prefix, (unsigned)i);
762
763 for (j = 0; j < 16 && (i + j) < len; j ++)
764 {
765 if (j && !(j & 3))
766 fprintf(stderr, " %02x", buffer[i + j]);
767 else
768 fprintf(stderr, " %02x", buffer[i + j]);
769 }
770
771 while (j < 16)
772 {
773 if (j && !(j & 3))
774 fputs(" ", stderr);
775 else
776 fputs(" ", stderr);
777
778 j ++;
779 }
780
781 fputs(" ", stderr);
782
783 for (j = 0; j < 16 && (i + j) < len; j ++)
784 if (buffer[i + j] < ' ' || buffer[i + j] >= 0x7f)
785 putc('.', stderr);
786 else
787 putc(buffer[i + j], stderr);
788
789 putc('\n', stderr);
790 }
791 }
792
793 if (indent == 0)
794 fprintf(stderr, "%sMessage:\n", prefix);
795
796 bufend = buffer + len;
797
798 while (buffer < bufend)
799 {
800 /*
801 * Get value type...
802 */
803
804 value_type = (unsigned char)asn1_get_type(&buffer, bufend);
805 value_length = asn1_get_length(&buffer, bufend);
806
807 switch (value_type)
808 {
809 case CUPS_ASN1_BOOLEAN :
810 integer = asn1_get_integer(&buffer, bufend, value_length);
811
812 fprintf(stderr, "%s%*sBOOLEAN %d bytes %d\n", prefix, indent, "",
813 value_length, integer);
814 break;
815
816 case CUPS_ASN1_INTEGER :
817 integer = asn1_get_integer(&buffer, bufend, value_length);
818
819 fprintf(stderr, "%s%*sINTEGER %d bytes %d\n", prefix, indent, "",
820 value_length, integer);
821 break;
822
823 case CUPS_ASN1_COUNTER :
824 integer = asn1_get_integer(&buffer, bufend, value_length);
825
826 fprintf(stderr, "%s%*sCOUNTER %d bytes %u\n", prefix, indent, "",
827 value_length, (unsigned)integer);
828 break;
829
830 case CUPS_ASN1_GAUGE :
831 integer = asn1_get_integer(&buffer, bufend, value_length);
832
833 fprintf(stderr, "%s%*sGAUGE %d bytes %u\n", prefix, indent, "",
834 value_length, (unsigned)integer);
835 break;
836
837 case CUPS_ASN1_TIMETICKS :
838 integer = asn1_get_integer(&buffer, bufend, value_length);
839
840 fprintf(stderr, "%s%*sTIMETICKS %d bytes %u\n", prefix, indent, "",
841 value_length, (unsigned)integer);
842 break;
843
844 case CUPS_ASN1_OCTET_STRING :
845 fprintf(stderr, "%s%*sOCTET STRING %d bytes \"%s\"\n", prefix,
846 indent, "", value_length,
847 asn1_get_string(&buffer, bufend, value_length, string,
848 sizeof(string)));
849 break;
850
851 case CUPS_ASN1_HEX_STRING :
852 asn1_get_string(&buffer, bufend, value_length, string,
853 sizeof(string));
854 fprintf(stderr, "%s%*sHex-STRING %d bytes", prefix,
855 indent, "", value_length);
856 for (i = 0; i < value_length; i ++)
857 fprintf(stderr, " %02X", string[i] & 255);
858 putc('\n', stderr);
859 break;
860
861 case CUPS_ASN1_NULL_VALUE :
862 fprintf(stderr, "%s%*sNULL VALUE %d bytes\n", prefix, indent, "",
863 value_length);
864
865 buffer += value_length;
866 break;
867
868 case CUPS_ASN1_OID :
869 integer = asn1_get_oid(&buffer, bufend, value_length, oid,
870 CUPS_SNMP_MAX_OID);
871
872 fprintf(stderr, "%s%*sOID %d bytes ", prefix, indent, "",
873 value_length);
874 for (i = 0; i < (unsigned)integer; i ++)
875 fprintf(stderr, ".%d", oid[i]);
876 putc('\n', stderr);
877 break;
878
879 case CUPS_ASN1_SEQUENCE :
880 fprintf(stderr, "%s%*sSEQUENCE %d bytes\n", prefix, indent, "",
881 value_length);
882 asn1_debug(prefix, buffer, value_length, indent + 4);
883
884 buffer += value_length;
885 break;
886
887 case CUPS_ASN1_GET_NEXT_REQUEST :
888 fprintf(stderr, "%s%*sGet-Next-Request-PDU %d bytes\n", prefix,
889 indent, "", value_length);
890 asn1_debug(prefix, buffer, value_length, indent + 4);
891
892 buffer += value_length;
893 break;
894
895 case CUPS_ASN1_GET_REQUEST :
896 fprintf(stderr, "%s%*sGet-Request-PDU %d bytes\n", prefix, indent, "",
897 value_length);
898 asn1_debug(prefix, buffer, value_length, indent + 4);
899
900 buffer += value_length;
901 break;
902
903 case CUPS_ASN1_GET_RESPONSE :
904 fprintf(stderr, "%s%*sGet-Response-PDU %d bytes\n", prefix, indent,
905 "", value_length);
906 asn1_debug(prefix, buffer, value_length, indent + 4);
907
908 buffer += value_length;
909 break;
910
911 default :
912 fprintf(stderr, "%s%*sUNKNOWN(%x) %d bytes\n", prefix, indent, "",
913 value_type, value_length);
914
915 buffer += value_length;
916 break;
917 }
918 }
919 }
920
921
922 /*
923 * 'asn1_decode_snmp()' - Decode a SNMP packet.
924 */
925
926 static int /* O - 0 on success, -1 on error */
asn1_decode_snmp(unsigned char * buffer,size_t len,cups_snmp_t * packet)927 asn1_decode_snmp(unsigned char *buffer, /* I - Buffer */
928 size_t len, /* I - Size of buffer */
929 cups_snmp_t *packet) /* I - SNMP packet */
930 {
931 unsigned char *bufptr, /* Pointer into the data */
932 *bufend; /* End of data */
933 unsigned length; /* Length of value */
934
935
936 /*
937 * Initialize the decoding...
938 */
939
940 memset(packet, 0, sizeof(cups_snmp_t));
941 packet->object_name[0] = -1;
942
943 bufptr = buffer;
944 bufend = buffer + len;
945
946 if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
947 snmp_set_error(packet, _("Packet does not start with SEQUENCE"));
948 else if (asn1_get_length(&bufptr, bufend) == 0)
949 snmp_set_error(packet, _("SEQUENCE uses indefinite length"));
950 else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
951 snmp_set_error(packet, _("No version number"));
952 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
953 snmp_set_error(packet, _("Version uses indefinite length"));
954 else if ((packet->version = asn1_get_integer(&bufptr, bufend, length))
955 != CUPS_SNMP_VERSION_1)
956 snmp_set_error(packet, _("Bad SNMP version number"));
957 else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_OCTET_STRING)
958 snmp_set_error(packet, _("No community name"));
959 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
960 snmp_set_error(packet, _("Community name uses indefinite length"));
961 else
962 {
963 asn1_get_string(&bufptr, bufend, length, packet->community,
964 sizeof(packet->community));
965
966 if ((packet->request_type = (cups_asn1_t)asn1_get_type(&bufptr, bufend))
967 != CUPS_ASN1_GET_RESPONSE)
968 snmp_set_error(packet, _("Packet does not contain a Get-Response-PDU"));
969 else if (asn1_get_length(&bufptr, bufend) == 0)
970 snmp_set_error(packet, _("Get-Response-PDU uses indefinite length"));
971 else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
972 snmp_set_error(packet, _("No request-id"));
973 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
974 snmp_set_error(packet, _("request-id uses indefinite length"));
975 else
976 {
977 packet->request_id = (unsigned)asn1_get_integer(&bufptr, bufend, length);
978
979 if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
980 snmp_set_error(packet, _("No error-status"));
981 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
982 snmp_set_error(packet, _("error-status uses indefinite length"));
983 else
984 {
985 packet->error_status = asn1_get_integer(&bufptr, bufend, length);
986
987 if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
988 snmp_set_error(packet, _("No error-index"));
989 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
990 snmp_set_error(packet, _("error-index uses indefinite length"));
991 else
992 {
993 packet->error_index = asn1_get_integer(&bufptr, bufend, length);
994
995 if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
996 snmp_set_error(packet, _("No variable-bindings SEQUENCE"));
997 else if (asn1_get_length(&bufptr, bufend) == 0)
998 snmp_set_error(packet,
999 _("variable-bindings uses indefinite length"));
1000 else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
1001 snmp_set_error(packet, _("No VarBind SEQUENCE"));
1002 else if (asn1_get_length(&bufptr, bufend) == 0)
1003 snmp_set_error(packet, _("VarBind uses indefinite length"));
1004 else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_OID)
1005 snmp_set_error(packet, _("No name OID"));
1006 else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
1007 snmp_set_error(packet, _("Name OID uses indefinite length"));
1008 else
1009 {
1010 asn1_get_oid(&bufptr, bufend, length, packet->object_name,
1011 CUPS_SNMP_MAX_OID);
1012
1013 packet->object_type = (cups_asn1_t)asn1_get_type(&bufptr, bufend);
1014
1015 if ((length = asn1_get_length(&bufptr, bufend)) == 0 &&
1016 packet->object_type != CUPS_ASN1_NULL_VALUE &&
1017 packet->object_type != CUPS_ASN1_OCTET_STRING)
1018 snmp_set_error(packet, _("Value uses indefinite length"));
1019 else
1020 {
1021 switch (packet->object_type)
1022 {
1023 case CUPS_ASN1_BOOLEAN :
1024 packet->object_value.boolean =
1025 asn1_get_integer(&bufptr, bufend, length);
1026 break;
1027
1028 case CUPS_ASN1_INTEGER :
1029 packet->object_value.integer =
1030 asn1_get_integer(&bufptr, bufend, length);
1031 break;
1032
1033 case CUPS_ASN1_NULL_VALUE :
1034 break;
1035
1036 case CUPS_ASN1_OCTET_STRING :
1037 case CUPS_ASN1_BIT_STRING :
1038 case CUPS_ASN1_HEX_STRING :
1039 packet->object_value.string.num_bytes = length;
1040 asn1_get_string(&bufptr, bufend, length,
1041 (char *)packet->object_value.string.bytes,
1042 sizeof(packet->object_value.string.bytes));
1043 break;
1044
1045 case CUPS_ASN1_OID :
1046 asn1_get_oid(&bufptr, bufend, length,
1047 packet->object_value.oid, CUPS_SNMP_MAX_OID);
1048 break;
1049
1050 case CUPS_ASN1_COUNTER :
1051 packet->object_value.counter =
1052 asn1_get_integer(&bufptr, bufend, length);
1053 break;
1054
1055 case CUPS_ASN1_GAUGE :
1056 packet->object_value.gauge =
1057 (unsigned)asn1_get_integer(&bufptr, bufend, length);
1058 break;
1059
1060 case CUPS_ASN1_TIMETICKS :
1061 packet->object_value.timeticks =
1062 (unsigned)asn1_get_integer(&bufptr, bufend, length);
1063 break;
1064
1065 default :
1066 snmp_set_error(packet, _("Unsupported value type"));
1067 break;
1068 }
1069 }
1070 }
1071 }
1072 }
1073 }
1074 }
1075
1076 return (packet->error ? -1 : 0);
1077 }
1078
1079
1080 /*
1081 * 'asn1_encode_snmp()' - Encode a SNMP packet.
1082 */
1083
1084 static int /* O - Length on success, -1 on error */
asn1_encode_snmp(unsigned char * buffer,size_t bufsize,cups_snmp_t * packet)1085 asn1_encode_snmp(unsigned char *buffer, /* I - Buffer */
1086 size_t bufsize, /* I - Size of buffer */
1087 cups_snmp_t *packet) /* I - SNMP packet */
1088 {
1089 unsigned char *bufptr; /* Pointer into buffer */
1090 unsigned total, /* Total length */
1091 msglen, /* Length of entire message */
1092 commlen, /* Length of community string */
1093 reqlen, /* Length of request */
1094 listlen, /* Length of variable list */
1095 varlen, /* Length of variable */
1096 namelen, /* Length of object name OID */
1097 valuelen; /* Length of object value */
1098
1099
1100 /*
1101 * Get the lengths of the community string, OID, and message...
1102 */
1103
1104
1105 namelen = asn1_size_oid(packet->object_name);
1106
1107 switch (packet->object_type)
1108 {
1109 case CUPS_ASN1_NULL_VALUE :
1110 valuelen = 0;
1111 break;
1112
1113 case CUPS_ASN1_BOOLEAN :
1114 valuelen = asn1_size_integer(packet->object_value.boolean);
1115 break;
1116
1117 case CUPS_ASN1_INTEGER :
1118 valuelen = asn1_size_integer(packet->object_value.integer);
1119 break;
1120
1121 case CUPS_ASN1_OCTET_STRING :
1122 valuelen = packet->object_value.string.num_bytes;
1123 break;
1124
1125 case CUPS_ASN1_OID :
1126 valuelen = asn1_size_oid(packet->object_value.oid);
1127 break;
1128
1129 default :
1130 packet->error = "Unknown object type";
1131 return (-1);
1132 }
1133
1134 varlen = 1 + asn1_size_length(namelen) + namelen +
1135 1 + asn1_size_length(valuelen) + valuelen;
1136 listlen = 1 + asn1_size_length(varlen) + varlen;
1137 reqlen = 2 + asn1_size_integer((int)packet->request_id) +
1138 2 + asn1_size_integer(packet->error_status) +
1139 2 + asn1_size_integer(packet->error_index) +
1140 1 + asn1_size_length(listlen) + listlen;
1141 commlen = (unsigned)strlen(packet->community);
1142 msglen = 2 + asn1_size_integer(packet->version) +
1143 1 + asn1_size_length(commlen) + commlen +
1144 1 + asn1_size_length(reqlen) + reqlen;
1145 total = 1 + asn1_size_length(msglen) + msglen;
1146
1147 if (total > bufsize)
1148 {
1149 packet->error = "Message too large for buffer";
1150 return (-1);
1151 }
1152
1153 /*
1154 * Then format the message...
1155 */
1156
1157 bufptr = buffer;
1158
1159 *bufptr++ = CUPS_ASN1_SEQUENCE; /* SNMPv1 message header */
1160 asn1_set_length(&bufptr, msglen);
1161
1162 asn1_set_integer(&bufptr, packet->version);
1163 /* version */
1164
1165 *bufptr++ = CUPS_ASN1_OCTET_STRING; /* community */
1166 asn1_set_length(&bufptr, commlen);
1167 memcpy(bufptr, packet->community, commlen);
1168 bufptr += commlen;
1169
1170 *bufptr++ = (unsigned char)packet->request_type; /* Get-Request-PDU/Get-Next-Request-PDU */
1171 asn1_set_length(&bufptr, reqlen);
1172
1173 asn1_set_integer(&bufptr, (int)packet->request_id);
1174
1175 asn1_set_integer(&bufptr, packet->error_status);
1176
1177 asn1_set_integer(&bufptr, packet->error_index);
1178
1179 *bufptr++ = CUPS_ASN1_SEQUENCE; /* variable-bindings */
1180 asn1_set_length(&bufptr, listlen);
1181
1182 *bufptr++ = CUPS_ASN1_SEQUENCE; /* variable */
1183 asn1_set_length(&bufptr, varlen);
1184
1185 asn1_set_oid(&bufptr, packet->object_name);
1186 /* ObjectName */
1187
1188 switch (packet->object_type)
1189 {
1190 case CUPS_ASN1_NULL_VALUE :
1191 *bufptr++ = CUPS_ASN1_NULL_VALUE;
1192 /* ObjectValue */
1193 *bufptr++ = 0; /* Length */
1194 break;
1195
1196 case CUPS_ASN1_BOOLEAN :
1197 asn1_set_integer(&bufptr, packet->object_value.boolean);
1198 break;
1199
1200 case CUPS_ASN1_INTEGER :
1201 asn1_set_integer(&bufptr, packet->object_value.integer);
1202 break;
1203
1204 case CUPS_ASN1_OCTET_STRING :
1205 *bufptr++ = CUPS_ASN1_OCTET_STRING;
1206 asn1_set_length(&bufptr, valuelen);
1207 memcpy(bufptr, packet->object_value.string.bytes, valuelen);
1208 bufptr += valuelen;
1209 break;
1210
1211 case CUPS_ASN1_OID :
1212 asn1_set_oid(&bufptr, packet->object_value.oid);
1213 break;
1214
1215 default :
1216 break;
1217 }
1218
1219 return ((int)(bufptr - buffer));
1220 }
1221
1222
1223 /*
1224 * 'asn1_get_integer()' - Get an integer value.
1225 */
1226
1227 static int /* O - Integer value */
asn1_get_integer(unsigned char ** buffer,unsigned char * bufend,unsigned length)1228 asn1_get_integer(
1229 unsigned char **buffer, /* IO - Pointer in buffer */
1230 unsigned char *bufend, /* I - End of buffer */
1231 unsigned length) /* I - Length of value */
1232 {
1233 int value; /* Integer value */
1234
1235
1236 if (*buffer >= bufend)
1237 return (0);
1238
1239 if (length > sizeof(int))
1240 {
1241 (*buffer) += length;
1242 return (0);
1243 }
1244
1245 for (value = (**buffer & 0x80) ? ~0 : 0;
1246 length > 0 && *buffer < bufend;
1247 length --, (*buffer) ++)
1248 value = ((value & 0xffffff) << 8) | **buffer;
1249
1250 return (value);
1251 }
1252
1253
1254 /*
1255 * 'asn1_get_length()' - Get a value length.
1256 */
1257
1258 static unsigned /* O - Length */
asn1_get_length(unsigned char ** buffer,unsigned char * bufend)1259 asn1_get_length(unsigned char **buffer, /* IO - Pointer in buffer */
1260 unsigned char *bufend) /* I - End of buffer */
1261 {
1262 unsigned length; /* Length */
1263
1264
1265 if (*buffer >= bufend)
1266 return (0);
1267
1268 length = **buffer;
1269 (*buffer) ++;
1270
1271 if (length & 128)
1272 {
1273 int count; /* Number of bytes for length */
1274
1275
1276 if ((count = length & 127) > sizeof(unsigned))
1277 {
1278 (*buffer) += count;
1279 return (0);
1280 }
1281
1282 for (length = 0;
1283 count > 0 && *buffer < bufend;
1284 count --, (*buffer) ++)
1285 length = (length << 8) | **buffer;
1286 }
1287
1288 return (length);
1289 }
1290
1291
1292 /*
1293 * 'asn1_get_oid()' - Get an OID value.
1294 */
1295
1296 static int /* O - Number of OIDs */
asn1_get_oid(unsigned char ** buffer,unsigned char * bufend,unsigned length,int * oid,int oidsize)1297 asn1_get_oid(
1298 unsigned char **buffer, /* IO - Pointer in buffer */
1299 unsigned char *bufend, /* I - End of buffer */
1300 unsigned length, /* I - Length of value */
1301 int *oid, /* I - OID buffer */
1302 int oidsize) /* I - Size of OID buffer */
1303 {
1304 unsigned char *valend; /* End of value */
1305 int *oidptr, /* Current OID */
1306 *oidend; /* End of OID buffer */
1307 int number; /* OID number */
1308
1309
1310 if (*buffer >= bufend)
1311 return (0);
1312
1313 valend = *buffer + length;
1314 oidptr = oid;
1315 oidend = oid + oidsize - 1;
1316
1317 if (valend > bufend)
1318 valend = bufend;
1319
1320 number = asn1_get_packed(buffer, bufend);
1321
1322 if (number < 80)
1323 {
1324 *oidptr++ = number / 40;
1325 number = number % 40;
1326 *oidptr++ = number;
1327 }
1328 else
1329 {
1330 *oidptr++ = 2;
1331 number -= 80;
1332 *oidptr++ = number;
1333 }
1334
1335 while (*buffer < valend)
1336 {
1337 number = asn1_get_packed(buffer, bufend);
1338
1339 if (oidptr < oidend)
1340 *oidptr++ = number;
1341 }
1342
1343 *oidptr = -1;
1344
1345 return ((int)(oidptr - oid));
1346 }
1347
1348
1349 /*
1350 * 'asn1_get_packed()' - Get a packed integer value.
1351 */
1352
1353 static int /* O - Value */
asn1_get_packed(unsigned char ** buffer,unsigned char * bufend)1354 asn1_get_packed(
1355 unsigned char **buffer, /* IO - Pointer in buffer */
1356 unsigned char *bufend) /* I - End of buffer */
1357 {
1358 int value; /* Value */
1359
1360
1361 if (*buffer >= bufend)
1362 return (0);
1363
1364 value = 0;
1365
1366 while (*buffer < bufend && (**buffer & 128))
1367 {
1368 value = (value << 7) | (**buffer & 127);
1369 (*buffer) ++;
1370 }
1371
1372 if (*buffer < bufend)
1373 {
1374 value = (value << 7) | **buffer;
1375 (*buffer) ++;
1376 }
1377
1378 return (value);
1379 }
1380
1381
1382 /*
1383 * 'asn1_get_string()' - Get a string value.
1384 */
1385
1386 static char * /* O - String */
asn1_get_string(unsigned char ** buffer,unsigned char * bufend,unsigned length,char * string,size_t strsize)1387 asn1_get_string(
1388 unsigned char **buffer, /* IO - Pointer in buffer */
1389 unsigned char *bufend, /* I - End of buffer */
1390 unsigned length, /* I - Value length */
1391 char *string, /* I - String buffer */
1392 size_t strsize) /* I - String buffer size */
1393 {
1394 if (*buffer >= bufend)
1395 return (NULL);
1396
1397 if (length > (unsigned)(bufend - *buffer))
1398 length = (unsigned)(bufend - *buffer);
1399
1400 if (length < strsize)
1401 {
1402 /*
1403 * String is smaller than the buffer...
1404 */
1405
1406 if (length > 0)
1407 memcpy(string, *buffer, length);
1408
1409 string[length] = '\0';
1410 }
1411 else
1412 {
1413 /*
1414 * String is larger than the buffer...
1415 */
1416
1417 memcpy(string, *buffer, strsize - 1);
1418 string[strsize - 1] = '\0';
1419 }
1420
1421 if (length > 0)
1422 (*buffer) += length;
1423
1424 return (string);
1425 }
1426
1427
1428 /*
1429 * 'asn1_get_type()' - Get a value type.
1430 */
1431
1432 static int /* O - Type */
asn1_get_type(unsigned char ** buffer,unsigned char * bufend)1433 asn1_get_type(unsigned char **buffer, /* IO - Pointer in buffer */
1434 unsigned char *bufend) /* I - End of buffer */
1435 {
1436 int type; /* Type */
1437
1438
1439 if (*buffer >= bufend)
1440 return (0);
1441
1442 type = **buffer;
1443 (*buffer) ++;
1444
1445 if ((type & 31) == 31)
1446 type = asn1_get_packed(buffer, bufend);
1447
1448 return (type);
1449 }
1450
1451
1452 /*
1453 * 'asn1_set_integer()' - Set an integer value.
1454 */
1455
1456 static void
asn1_set_integer(unsigned char ** buffer,int integer)1457 asn1_set_integer(unsigned char **buffer,/* IO - Pointer in buffer */
1458 int integer) /* I - Integer value */
1459 {
1460 **buffer = CUPS_ASN1_INTEGER;
1461 (*buffer) ++;
1462
1463 if (integer > 0x7fffff || integer < -0x800000)
1464 {
1465 **buffer = 4;
1466 (*buffer) ++;
1467 **buffer = (unsigned char)(integer >> 24);
1468 (*buffer) ++;
1469 **buffer = (unsigned char)(integer >> 16);
1470 (*buffer) ++;
1471 **buffer = (unsigned char)(integer >> 8);
1472 (*buffer) ++;
1473 **buffer = (unsigned char)integer;
1474 (*buffer) ++;
1475 }
1476 else if (integer > 0x7fff || integer < -0x8000)
1477 {
1478 **buffer = 3;
1479 (*buffer) ++;
1480 **buffer = (unsigned char)(integer >> 16);
1481 (*buffer) ++;
1482 **buffer = (unsigned char)(integer >> 8);
1483 (*buffer) ++;
1484 **buffer = (unsigned char)integer;
1485 (*buffer) ++;
1486 }
1487 else if (integer > 0x7f || integer < -0x80)
1488 {
1489 **buffer = 2;
1490 (*buffer) ++;
1491 **buffer = (unsigned char)(integer >> 8);
1492 (*buffer) ++;
1493 **buffer = (unsigned char)integer;
1494 (*buffer) ++;
1495 }
1496 else
1497 {
1498 **buffer = 1;
1499 (*buffer) ++;
1500 **buffer = (unsigned char)integer;
1501 (*buffer) ++;
1502 }
1503 }
1504
1505
1506 /*
1507 * 'asn1_set_length()' - Set a value length.
1508 */
1509
1510 static void
asn1_set_length(unsigned char ** buffer,unsigned length)1511 asn1_set_length(unsigned char **buffer, /* IO - Pointer in buffer */
1512 unsigned length) /* I - Length value */
1513 {
1514 if (length > 255)
1515 {
1516 **buffer = 0x82; /* 2-byte length */
1517 (*buffer) ++;
1518 **buffer = (unsigned char)(length >> 8);
1519 (*buffer) ++;
1520 **buffer = (unsigned char)length;
1521 (*buffer) ++;
1522 }
1523 else if (length > 127)
1524 {
1525 **buffer = 0x81; /* 1-byte length */
1526 (*buffer) ++;
1527 **buffer = (unsigned char)length;
1528 (*buffer) ++;
1529 }
1530 else
1531 {
1532 **buffer = (unsigned char)length; /* Length */
1533 (*buffer) ++;
1534 }
1535 }
1536
1537
1538 /*
1539 * 'asn1_set_oid()' - Set an OID value.
1540 */
1541
1542 static void
asn1_set_oid(unsigned char ** buffer,const int * oid)1543 asn1_set_oid(unsigned char **buffer, /* IO - Pointer in buffer */
1544 const int *oid) /* I - OID value */
1545 {
1546 **buffer = CUPS_ASN1_OID;
1547 (*buffer) ++;
1548
1549 asn1_set_length(buffer, asn1_size_oid(oid));
1550
1551 if (oid[1] < 0)
1552 {
1553 asn1_set_packed(buffer, oid[0] * 40);
1554 return;
1555 }
1556
1557 asn1_set_packed(buffer, oid[0] * 40 + oid[1]);
1558
1559 for (oid += 2; *oid >= 0; oid ++)
1560 asn1_set_packed(buffer, *oid);
1561 }
1562
1563
1564 /*
1565 * 'asn1_set_packed()' - Set a packed integer value.
1566 */
1567
1568 static void
asn1_set_packed(unsigned char ** buffer,int integer)1569 asn1_set_packed(unsigned char **buffer, /* IO - Pointer in buffer */
1570 int integer) /* I - Integer value */
1571 {
1572 if (integer > 0xfffffff)
1573 {
1574 **buffer = ((integer >> 28) & 0x7f) | 0x80;
1575 (*buffer) ++;
1576 }
1577
1578 if (integer > 0x1fffff)
1579 {
1580 **buffer = ((integer >> 21) & 0x7f) | 0x80;
1581 (*buffer) ++;
1582 }
1583
1584 if (integer > 0x3fff)
1585 {
1586 **buffer = ((integer >> 14) & 0x7f) | 0x80;
1587 (*buffer) ++;
1588 }
1589
1590 if (integer > 0x7f)
1591 {
1592 **buffer = ((integer >> 7) & 0x7f) | 0x80;
1593 (*buffer) ++;
1594 }
1595
1596 **buffer = integer & 0x7f;
1597 (*buffer) ++;
1598 }
1599
1600
1601 /*
1602 * 'asn1_size_integer()' - Figure out the number of bytes needed for an
1603 * integer value.
1604 */
1605
1606 static unsigned /* O - Size in bytes */
asn1_size_integer(int integer)1607 asn1_size_integer(int integer) /* I - Integer value */
1608 {
1609 if (integer > 0x7fffff || integer < -0x800000)
1610 return (4);
1611 else if (integer > 0x7fff || integer < -0x8000)
1612 return (3);
1613 else if (integer > 0x7f || integer < -0x80)
1614 return (2);
1615 else
1616 return (1);
1617 }
1618
1619
1620 /*
1621 * 'asn1_size_length()' - Figure out the number of bytes needed for a
1622 * length value.
1623 */
1624
1625 static unsigned /* O - Size in bytes */
asn1_size_length(unsigned length)1626 asn1_size_length(unsigned length) /* I - Length value */
1627 {
1628 if (length > 0xff)
1629 return (3);
1630 else if (length > 0x7f)
1631 return (2);
1632 else
1633 return (1);
1634 }
1635
1636
1637 /*
1638 * 'asn1_size_oid()' - Figure out the number of bytes needed for an
1639 * OID value.
1640 */
1641
1642 static unsigned /* O - Size in bytes */
asn1_size_oid(const int * oid)1643 asn1_size_oid(const int *oid) /* I - OID value */
1644 {
1645 unsigned length; /* Length of value */
1646
1647
1648 if (oid[1] < 0)
1649 return (asn1_size_packed(oid[0] * 40));
1650
1651 for (length = asn1_size_packed(oid[0] * 40 + oid[1]), oid += 2;
1652 *oid >= 0;
1653 oid ++)
1654 length += asn1_size_packed(*oid);
1655
1656 return (length);
1657 }
1658
1659
1660 /*
1661 * 'asn1_size_packed()' - Figure out the number of bytes needed for a
1662 * packed integer value.
1663 */
1664
1665 static unsigned /* O - Size in bytes */
asn1_size_packed(int integer)1666 asn1_size_packed(int integer) /* I - Integer value */
1667 {
1668 if (integer > 0xfffffff)
1669 return (5);
1670 else if (integer > 0x1fffff)
1671 return (4);
1672 else if (integer > 0x3fff)
1673 return (3);
1674 else if (integer > 0x7f)
1675 return (2);
1676 else
1677 return (1);
1678 }
1679
1680
1681 /*
1682 * 'snmp_set_error()' - Set the localized error for a packet.
1683 */
1684
1685 static void
snmp_set_error(cups_snmp_t * packet,const char * message)1686 snmp_set_error(cups_snmp_t *packet, /* I - Packet */
1687 const char *message) /* I - Error message */
1688 {
1689 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1690
1691
1692 if (!cg->lang_default)
1693 cg->lang_default = cupsLangDefault();
1694
1695 packet->error = _cupsLangString(cg->lang_default, message);
1696 }
1697