asn1.c

00001 /*
00002  * Abstract Syntax Notation One, ASN.1
00003  * As defined in ISO/IS 8824 and ISO/IS 8825
00004  * This implements a subset of the above International Standards that
00005  * is sufficient to implement SNMP.
00006  *
00007  * Encodes abstract data types into a machine independent stream of bytes.
00008  *
00009  */
00010 /**********************************************************************
00011         Copyright 1988, 1989, 1991, 1992 by Carnegie Mellon University
00012 
00013                       All Rights Reserved
00014 
00015 Permission to use, copy, modify, and distribute this software and its 
00016 documentation for any purpose and without fee is hereby granted, 
00017 provided that the above copyright notice appear in all copies and that
00018 both that copyright notice and this permission notice appear in 
00019 supporting documentation, and that the name of CMU not be
00020 used in advertising or publicity pertaining to distribution of the
00021 software without specific, written prior permission.  
00022 
00023 CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
00024 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
00025 CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
00026 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
00027 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
00028 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
00029 SOFTWARE.
00030 ******************************************************************/
00156 #include <net-snmp/net-snmp-config.h>
00157 
00158 #ifdef KINETICS
00159 #include "gw.h"
00160 #endif
00161 
00162 #if HAVE_STRING_H
00163 #include <string.h>
00164 #else
00165 #include <strings.h>
00166 #endif
00167 
00168 #include <sys/types.h>
00169 #include <stdio.h>
00170 #ifdef HAVE_STDLIB_H
00171 #include <stdlib.h>
00172 #endif
00173 #if HAVE_WINSOCK_H
00174 #include <winsock.h>
00175 #endif
00176 #if HAVE_NETINET_IN_H
00177 #include <netinet/in.h>
00178 #endif
00179 
00180 #ifdef vms
00181 #include <in.h>
00182 #endif
00183 
00184 #if HAVE_DMALLOC_H
00185 #include <dmalloc.h>
00186 #endif
00187 
00188 #include <net-snmp/output_api.h>
00189 #include <net-snmp/utilities.h>
00190 
00191 #include <net-snmp/library/asn1.h>
00192 #include <net-snmp/library/int64.h>
00193 #include <net-snmp/library/mib.h>
00194 
00195 #ifndef NULL
00196 #define NULL    0
00197 #endif
00198 
00199 #include <net-snmp/library/snmp_api.h>
00200 
00201 #ifndef INT32_MAX
00202 #   define INT32_MAX 2147483647
00203 #endif
00204 
00205 #ifndef INT32_MIN
00206 #   define INT32_MIN (0 - INT32_MAX - 1)
00207 #endif
00208 
00209 
00210 #if SIZEOF_LONG == 4
00211 #  define CHECK_OVERFLOW_S(x,y)
00212 #  define CHECK_OVERFLOW_U(x,y)
00213 #else
00214 #  define CHECK_OVERFLOW_S(x,y) do { int trunc = 0;                     \
00215         if (x > INT32_MAX) {                                            \
00216             trunc = 1;                                                  \
00217             x &= 0xffffffff;                                            \
00218         } else if (x < INT32_MIN) {                                     \
00219             trunc = 1;                                                  \
00220             x = 0 - (x & 0xffffffff);                                   \
00221         }                                                               \
00222         if (trunc)                                                      \
00223             DEBUGMSG(("asn","truncating signed value to 32 bits (%d)\n",y)); \
00224     } while(0)
00225 
00226 #  define CHECK_OVERFLOW_U(x,y) do {                                    \
00227         if (x > UINT32_MAX) {                                           \
00228             x &= 0xffffffff;                                            \
00229             DEBUGMSG(("asn","truncating unsigned value to 32 bits (%d)\n",y)); \
00230         }                                                               \
00231     } while(0)
00232 #endif
00233 
00242 static
00243     void
00244 _asn_size_err(const char *str, size_t wrongsize, size_t rightsize)
00245 {
00246     char            ebuf[128];
00247 
00248     snprintf(ebuf, sizeof(ebuf),
00249             "%s size %lu: s/b %lu", str,
00250             (unsigned long)wrongsize, (unsigned long)rightsize);
00251     ebuf[ sizeof(ebuf)-1 ] = 0;
00252     ERROR_MSG(ebuf);
00253 }
00254 
00263 static
00264     void
00265 _asn_length_err(const char *str, size_t wrongsize, size_t rightsize)
00266 {
00267     char            ebuf[128];
00268 
00269     snprintf(ebuf, sizeof(ebuf),
00270             "%s length %lu too large: exceeds %lu", str,
00271             (unsigned long)wrongsize, (unsigned long)rightsize);
00272     ebuf[ sizeof(ebuf)-1 ] = 0;
00273     ERROR_MSG(ebuf);
00274 }
00275 
00288 static
00289     int
00290 _asn_parse_length_check(const char *str,
00291                         const u_char * bufp, const u_char * data,
00292                         u_long plen, size_t dlen)
00293 {
00294     char            ebuf[128];
00295     size_t          header_len;
00296 
00297     if (bufp == NULL) {
00298         /*
00299          * error message is set 
00300          */
00301         return 1;
00302     }
00303     header_len = bufp - data;
00304     if (plen > 0x7fffffff || header_len > 0x7fffffff ||
00305         ((size_t) plen + header_len) > dlen) {
00306         snprintf(ebuf, sizeof(ebuf),
00307                 "%s: message overflow: %d len + %d delta > %d len",
00308                 str, (int) plen, (int) header_len, (int) dlen);
00309         ebuf[ sizeof(ebuf)-1 ] = 0;
00310         ERROR_MSG(ebuf);
00311         return 1;
00312     }
00313     return 0;
00314 }
00315 
00316 
00328 static
00329     int
00330 _asn_build_header_check(const char *str, const u_char * data,
00331                         size_t datalen, size_t typedlen)
00332 {
00333     char            ebuf[128];
00334 
00335     if (data == NULL) {
00336         /*
00337          * error message is set 
00338          */
00339         return 1;
00340     }
00341     if (datalen < typedlen) {
00342         snprintf(ebuf, sizeof(ebuf),
00343                 "%s: bad header, length too short: %lu < %lu", str,
00344                 (unsigned long)datalen, (unsigned long)typedlen);
00345         ebuf[ sizeof(ebuf)-1 ] = 0;
00346         ERROR_MSG(ebuf);
00347         return 1;
00348     }
00349     return 0;
00350 }
00351 
00363 static
00364     int
00365 _asn_realloc_build_header_check(const char *str,
00366                                 u_char ** pkt,
00367                                 const size_t * pkt_len, size_t typedlen)
00368 {
00369     char            ebuf[128];
00370 
00371     if (pkt == NULL || *pkt == NULL) {
00372         /*
00373          * Error message is set.  
00374          */
00375         return 1;
00376     }
00377 
00378     if (*pkt_len < typedlen) {
00379         snprintf(ebuf, sizeof(ebuf),
00380                 "%s: bad header, length too short: %lu < %lu", str,
00381                 (unsigned long)*pkt_len, (unsigned long)typedlen);
00382         ebuf[ sizeof(ebuf)-1 ] = 0;
00383         ERROR_MSG(ebuf);
00384         return 1;
00385     }
00386     return 0;
00387 }
00388 
00398 int
00399 asn_check_packet(u_char * pkt, size_t len)
00400 {
00401     u_long          asn_length;
00402 
00403     if (len < 2)
00404         return 0;               /* always too short */
00405 
00406     if (*pkt != (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR))
00407         return -1;              /* wrong type */
00408 
00409     if (*(pkt + 1) & 0x80) {
00410         /*
00411          * long length 
00412          */
00413         if ((int) len < (int) (*(pkt + 1) & ~0x80) + 2)
00414             return 0;           /* still to short, incomplete length */
00415         asn_parse_length(pkt + 1, &asn_length);
00416         return (asn_length + 2 + (*(pkt + 1) & ~0x80));
00417     } else {
00418         /*
00419          * short length 
00420          */
00421         return (*(pkt + 1) + 2);
00422     }
00423 }
00424 
00425 static
00426     int
00427 _asn_bitstring_check(const char *str, size_t asn_length, u_char datum)
00428 {
00429     char            ebuf[128];
00430 
00431     if (asn_length < 1) {
00432         snprintf(ebuf, sizeof(ebuf),
00433                 "%s: length %d too small", str, (int) asn_length);
00434         ebuf[ sizeof(ebuf)-1 ] = 0;
00435         ERROR_MSG(ebuf);
00436         return 1;
00437     }
00438     /*
00439      * if (datum > 7){
00440      * sprintf(ebuf,"%s: datum %d >7: too large", str, (int)(datum));
00441      * ERROR_MSG(ebuf);
00442      * return 1;
00443      * }
00444      */
00445     return 0;
00446 }
00447 
00469 u_char         *
00470 asn_parse_int(u_char * data,
00471               size_t * datalength,
00472               u_char * type, long *intp, size_t intsize)
00473 {
00474     /*
00475      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
00476      */
00477     static const char *errpre = "parse int";
00478     register u_char *bufp = data;
00479     u_long          asn_length;
00480     register long   value = 0;
00481 
00482     if (intsize != sizeof(long)) {
00483         _asn_size_err(errpre, intsize, sizeof(long));
00484         return NULL;
00485     }
00486     *type = *bufp++;
00487     bufp = asn_parse_length(bufp, &asn_length);
00488     if (_asn_parse_length_check
00489         (errpre, bufp, data, asn_length, *datalength))
00490         return NULL;
00491 
00492     if ((size_t) asn_length > intsize) {
00493         _asn_length_err(errpre, (size_t) asn_length, intsize);
00494         return NULL;
00495     }
00496 
00497     *datalength -= (int) asn_length + (bufp - data);
00498     if (*bufp & 0x80)
00499         value = -1;             /* integer is negative */
00500 
00501     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
00502 
00503     while (asn_length--)
00504         value = (value << 8) | *bufp++;
00505 
00506     CHECK_OVERFLOW_S(value,1);
00507 
00508     DEBUGMSG(("dumpv_recv", "  Integer:\t%ld (0x%.2lX)\n", value, value));
00509 
00510     *intp = value;
00511     return bufp;
00512 }
00513 
00514 
00536 u_char         *
00537 asn_parse_unsigned_int(u_char * data,
00538                        size_t * datalength,
00539                        u_char * type, u_long * intp, size_t intsize)
00540 {
00541     /*
00542      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
00543      */
00544     static const char *errpre = "parse uint";
00545     register u_char *bufp = data;
00546     u_long          asn_length;
00547     register u_long value = 0;
00548 
00549     if (intsize != sizeof(long)) {
00550         _asn_size_err(errpre, intsize, sizeof(long));
00551         return NULL;
00552     }
00553     *type = *bufp++;
00554     bufp = asn_parse_length(bufp, &asn_length);
00555     if (_asn_parse_length_check
00556         (errpre, bufp, data, asn_length, *datalength))
00557         return NULL;
00558 
00559     if (((int) asn_length > (intsize + 1)) ||
00560         (((int) asn_length == intsize + 1) && *bufp != 0x00)) {
00561         _asn_length_err(errpre, (size_t) asn_length, intsize);
00562         return NULL;
00563     }
00564     *datalength -= (int) asn_length + (bufp - data);
00565     if (*bufp & 0x80)
00566         value = ~value;         /* integer is negative */
00567 
00568     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
00569 
00570     while (asn_length--)
00571         value = (value << 8) | *bufp++;
00572 
00573     CHECK_OVERFLOW_U(value,2);
00574 
00575     DEBUGMSG(("dumpv_recv", "  UInteger:\t%ld (0x%.2lX)\n", value, value));
00576 
00577     *intp = value;
00578     return bufp;
00579 }
00580 
00581 
00605 u_char         *
00606 asn_build_int(u_char * data,
00607            size_t * datalength, u_char type, const long *intp, size_t intsize)
00608 {
00609     /*
00610      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
00611      */
00612     static const char *errpre = "build int";
00613     register long   integer;
00614     register u_long mask;
00615 #ifndef NETSNMP_NO_DEBUGGING
00616     u_char         *initdatap = data;
00617 #endif
00618 
00619     if (intsize != sizeof(long)) {
00620         _asn_size_err(errpre, intsize, sizeof(long));
00621         return NULL;
00622     }
00623     integer = *intp;
00624     CHECK_OVERFLOW_S(integer,3);
00625     /*
00626      * Truncate "unnecessary" bytes off of the most significant end of this
00627      * 2's complement integer.  There should be no sequence of 9
00628      * consecutive 1's or 0's at the most significant end of the
00629      * integer.
00630      */
00631     mask = ((u_long) 0x1FF) << ((8 * (sizeof(long) - 1)) - 1);
00632     /*
00633      * mask is 0xFF800000 on a big-endian machine 
00634      */
00635     while ((((integer & mask) == 0) || ((integer & mask) == mask))
00636            && intsize > 1) {
00637         intsize--;
00638         integer <<= 8;
00639     }
00640     data = asn_build_header(data, datalength, type, intsize);
00641     if (_asn_build_header_check(errpre, data, *datalength, intsize))
00642         return NULL;
00643 
00644     *datalength -= intsize;
00645     mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
00646     /*
00647      * mask is 0xFF000000 on a big-endian machine 
00648      */
00649     while (intsize--) {
00650         *data++ = (u_char) ((integer & mask) >> (8 * (sizeof(long) - 1)));
00651         integer <<= 8;
00652     }
00653     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
00654     DEBUGMSG(("dumpv_send", "  Integer:\t%ld (0x%.2lX)\n", *intp, *intp));
00655     return data;
00656 }
00657 
00658 
00659 
00683 u_char         *
00684 asn_build_unsigned_int(u_char * data,
00685                        size_t * datalength,
00686                        u_char type, const u_long * intp, size_t intsize)
00687 {
00688     /*
00689      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
00690      */
00691     static const char *errpre = "build uint";
00692     register u_long integer;
00693     register u_long mask;
00694     int             add_null_byte = 0;
00695 #ifndef NETSNMP_NO_DEBUGGING
00696     u_char         *initdatap = data;
00697 #endif
00698 
00699     if (intsize != sizeof(long)) {
00700         _asn_size_err(errpre, intsize, sizeof(long));
00701         return NULL;
00702     }
00703     integer = *intp;
00704     CHECK_OVERFLOW_U(integer,4);
00705 
00706     mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
00707     /*
00708      * mask is 0xFF000000 on a big-endian machine 
00709      */
00710     if ((u_char) ((integer & mask) >> (8 * (sizeof(long) - 1))) & 0x80) {
00711         /*
00712          * if MSB is set 
00713          */
00714         add_null_byte = 1;
00715         intsize++;
00716     } else {
00717         /*
00718          * Truncate "unnecessary" bytes off of the most significant end of this 2's complement integer.
00719          * There should be no sequence of 9 consecutive 1's or 0's at the most significant end of the
00720          * integer.
00721          */
00722         mask = ((u_long) 0x1FF) << ((8 * (sizeof(long) - 1)) - 1);
00723         /*
00724          * mask is 0xFF800000 on a big-endian machine 
00725          */
00726         while ((((integer & mask) == 0) || ((integer & mask) == mask))
00727                && intsize > 1) {
00728             intsize--;
00729             integer <<= 8;
00730         }
00731     }
00732     data = asn_build_header(data, datalength, type, intsize);
00733     if (_asn_build_header_check(errpre, data, *datalength, intsize))
00734         return NULL;
00735 
00736     *datalength -= intsize;
00737     if (add_null_byte == 1) {
00738         *data++ = '\0';
00739         intsize--;
00740     }
00741     mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
00742     /*
00743      * mask is 0xFF000000 on a big-endian machine 
00744      */
00745     while (intsize--) {
00746         *data++ = (u_char) ((integer & mask) >> (8 * (sizeof(long) - 1)));
00747         integer <<= 8;
00748     }
00749     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
00750     DEBUGMSG(("dumpv_send", "  UInteger:\t%ld (0x%.2lX)\n", *intp, *intp));
00751     return data;
00752 }
00753 
00754 
00783 u_char         *
00784 asn_parse_string(u_char * data,
00785                  size_t * datalength,
00786                  u_char * type, u_char * str, size_t * strlength)
00787 {
00788     static const char *errpre = "parse string";
00789     u_char         *bufp = data;
00790     u_long          asn_length;
00791 
00792     *type = *bufp++;
00793     bufp = asn_parse_length(bufp, &asn_length);
00794     if (_asn_parse_length_check
00795         (errpre, bufp, data, asn_length, *datalength)) {
00796         return NULL;
00797     }
00798 
00799     if ((int) asn_length > *strlength) {
00800         _asn_length_err(errpre, (size_t) asn_length, *strlength);
00801         return NULL;
00802     }
00803 
00804     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
00805 
00806     memmove(str, bufp, asn_length);
00807     if (*strlength > (int) asn_length)
00808         str[asn_length] = 0;
00809     *strlength = (int) asn_length;
00810     *datalength -= (int) asn_length + (bufp - data);
00811 
00812     DEBUGIF("dumpv_recv") {
00813         u_char         *buf = (u_char *) malloc(1 + asn_length);
00814         size_t          l = (buf != NULL) ? (1 + asn_length) : 0, ol = 0;
00815 
00816         if (sprint_realloc_asciistring
00817             (&buf, &l, &ol, 1, str, asn_length)) {
00818             DEBUGMSG(("dumpv_recv", "  String:\t%s\n", buf));
00819         } else {
00820             if (buf == NULL) {
00821                 DEBUGMSG(("dumpv_recv", "  String:\t[TRUNCATED]\n"));
00822             } else {
00823                 DEBUGMSG(("dumpv_recv", "  String:\t%s [TRUNCATED]\n",
00824                           buf));
00825             }
00826         }
00827         if (buf != NULL) {
00828             free(buf);
00829         }
00830     }
00831 
00832     return bufp + asn_length;
00833 }
00834 
00835 
00858 u_char         *
00859 asn_build_string(u_char * data,
00860                  size_t * datalength,
00861                  u_char type, const u_char * str, size_t strlength)
00862 {
00863     /*
00864      * ASN.1 octet string ::= primstring | cmpdstring
00865      * primstring ::= 0x04 asnlength byte {byte}*
00866      * cmpdstring ::= 0x24 asnlength string {string}*
00867      * This code will never send a compound string.
00868      */
00869 #ifndef NETSNMP_NO_DEBUGGING
00870     u_char         *initdatap = data;
00871 #endif
00872     data = asn_build_header(data, datalength, type, strlength);
00873     if (_asn_build_header_check
00874         ("build string", data, *datalength, strlength))
00875         return NULL;
00876 
00877     if (strlength) {
00878         if (str == NULL) {
00879             memset(data, 0, strlength);
00880         } else {
00881             memmove(data, str, strlength);
00882         }
00883     }
00884     *datalength -= strlength;
00885     DEBUGDUMPSETUP("send", initdatap, data - initdatap + strlength);
00886     DEBUGIF("dumpv_send") {
00887         u_char         *buf = (u_char *) malloc(1 + strlength);
00888         size_t          l = (buf != NULL) ? (1 + strlength) : 0, ol = 0;
00889 
00890         if (sprint_realloc_asciistring
00891             (&buf, &l, &ol, 1, str, strlength)) {
00892             DEBUGMSG(("dumpv_send", "  String:\t%s\n", buf));
00893         } else {
00894             if (buf == NULL) {
00895                 DEBUGMSG(("dumpv_send", "  String:\t[TRUNCATED]\n"));
00896             } else {
00897                 DEBUGMSG(("dumpv_send", "  String:\t%s [TRUNCATED]\n",
00898                           buf));
00899             }
00900         }
00901         if (buf != NULL) {
00902             free(buf);
00903         }
00904     }
00905     return data + strlength;
00906 }
00907 
00908 
00909 
00929 u_char         *
00930 asn_parse_header(u_char * data, size_t * datalength, u_char * type)
00931 {
00932     register u_char *bufp;
00933     u_long          asn_length;
00934 
00935     if (!data || !datalength || !type) {
00936         ERROR_MSG("parse header: NULL pointer");
00937         return NULL;
00938     }
00939     bufp = data;
00940     /*
00941      * this only works on data types < 30, i.e. no extension octets 
00942      */
00943     if (IS_EXTENSION_ID(*bufp)) {
00944         ERROR_MSG("can't process ID >= 30");
00945         return NULL;
00946     }
00947     *type = *bufp;
00948     bufp = asn_parse_length(bufp + 1, &asn_length);
00949 
00950     if (_asn_parse_length_check
00951         ("parse header", bufp, data, asn_length, *datalength))
00952         return NULL;
00953 
00954 #ifdef DUMP_PRINT_HEADERS
00955     DEBUGDUMPSETUP("recv", data, (bufp - data));
00956     DEBUGMSG(("dumpv_recv", "  Header: 0x%.2X, len = %d (0x%X)\n", *data,
00957               asn_length, asn_length));
00958 #else
00959     /*
00960      * DEBUGMSGHEXTLI(("recv",data,(bufp-data)));
00961      * DEBUGMSG(("dumpH_recv","\n"));
00962      */
00963 #endif
00964 
00965 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
00966 
00967     if ((*type == ASN_OPAQUE) && (*bufp == ASN_OPAQUE_TAG1)) {
00968 
00969         /*
00970          * check if 64-but counter 
00971          */
00972         switch (*(bufp + 1)) {
00973         case ASN_OPAQUE_COUNTER64:
00974         case ASN_OPAQUE_U64:
00975         case ASN_OPAQUE_FLOAT:
00976         case ASN_OPAQUE_DOUBLE:
00977         case ASN_OPAQUE_I64:
00978             *type = *(bufp + 1);
00979             break;
00980 
00981         default:
00982             /*
00983              * just an Opaque 
00984              */
00985             *datalength = (int) asn_length;
00986             return bufp;
00987         }
00988         /*
00989          * value is encoded as special format 
00990          */
00991         bufp = asn_parse_length(bufp + 2, &asn_length);
00992         if (_asn_parse_length_check("parse opaque header", bufp, data,
00993                                     asn_length, *datalength))
00994             return NULL;
00995     }
00996 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
00997 
00998     *datalength = (int) asn_length;
00999 
01000     return bufp;
01001 }
01002 
01017 u_char         *
01018 asn_parse_sequence(u_char * data, size_t * datalength, u_char * type, u_char expected_type,     /* must be this type */
01019                    const char *estr)
01020 {                               /* error message prefix */
01021     data = asn_parse_header(data, datalength, type);
01022     if (data && (*type != expected_type)) {
01023         char            ebuf[128];
01024         snprintf(ebuf, sizeof(ebuf),
01025                  "%s header type %02X: s/b %02X", estr,
01026                 (u_char) * type, (u_char) expected_type);
01027         ebuf[ sizeof(ebuf)-1 ] = 0;
01028         ERROR_MSG(ebuf);
01029         return NULL;
01030     }
01031     return data;
01032 }
01033 
01034 
01035 
01058 u_char         *
01059 asn_build_header(u_char * data,
01060                  size_t * datalength, u_char type, size_t length)
01061 {
01062     char            ebuf[128];
01063 
01064     if (*datalength < 1) {
01065         snprintf(ebuf, sizeof(ebuf),
01066                 "bad header length < 1 :%lu, %lu",
01067                 (unsigned long)*datalength, (unsigned long)length);
01068         ebuf[ sizeof(ebuf)-1 ] = 0;
01069         ERROR_MSG(ebuf);
01070         return NULL;
01071     }
01072     *data++ = type;
01073     (*datalength)--;
01074     return asn_build_length(data, datalength, length);
01075 }
01076 
01100 u_char         *
01101 asn_build_sequence(u_char * data,
01102                    size_t * datalength, u_char type, size_t length)
01103 {
01104     static const char *errpre = "build seq";
01105     char            ebuf[128];
01106 
01107     if (*datalength < 4) {
01108         snprintf(ebuf, sizeof(ebuf),
01109                 "%s: length %d < 4: PUNT", errpre,
01110                 (int) *datalength);
01111         ebuf[ sizeof(ebuf)-1 ] = 0;
01112         ERROR_MSG(ebuf);
01113         return NULL;
01114     }
01115     *datalength -= 4;
01116     *data++ = type;
01117     *data++ = (u_char) (0x02 | ASN_LONG_LEN);
01118     *data++ = (u_char) ((length >> 8) & 0xFF);
01119     *data++ = (u_char) (length & 0xFF);
01120     return data;
01121 }
01122 
01140 u_char         *
01141 asn_parse_length(u_char * data, u_long * length)
01142 {
01143     static const char *errpre = "parse length";
01144     char            ebuf[128];
01145     register u_char lengthbyte;
01146 
01147     if (!data || !length) {
01148         ERROR_MSG("parse length: NULL pointer");
01149         return NULL;
01150     }
01151     lengthbyte = *data;
01152 
01153     if (lengthbyte & ASN_LONG_LEN) {
01154         lengthbyte &= ~ASN_LONG_LEN;    /* turn MSb off */
01155         if (lengthbyte == 0) {
01156             snprintf(ebuf, sizeof(ebuf),
01157                      "%s: indefinite length not supported", errpre);
01158             ebuf[ sizeof(ebuf)-1 ] = 0;
01159             ERROR_MSG(ebuf);
01160             return NULL;
01161         }
01162         if (lengthbyte > sizeof(long)) {
01163             snprintf(ebuf, sizeof(ebuf),
01164                     "%s: data length %d > %lu not supported", errpre,
01165                     lengthbyte, (unsigned long)sizeof(long));
01166             ebuf[ sizeof(ebuf)-1 ] = 0;
01167             ERROR_MSG(ebuf);
01168             return NULL;
01169         }
01170         data++;
01171         *length = 0;            /* protect against short lengths */
01172         while (lengthbyte--) {
01173             *length <<= 8;
01174             *length |= *data++;
01175         }
01176         if ((long) *length < 0) {
01177             snprintf(ebuf, sizeof(ebuf),
01178                      "%s: negative data length %ld\n", errpre,
01179                      (long) *length);
01180             ebuf[ sizeof(ebuf)-1 ] = 0;
01181             ERROR_MSG(ebuf);
01182             return NULL;
01183         }
01184         return data;
01185     } else {                    /* short asnlength */
01186         *length = (long) lengthbyte;
01187         return data + 1;
01188     }
01189 }
01190 
01211 u_char         *
01212 asn_build_length(u_char * data, size_t * datalength, size_t length)
01213 {
01214     static const char *errpre = "build length";
01215     char            ebuf[128];
01216 
01217     u_char         *start_data = data;
01218 
01219     /*
01220      * no indefinite lengths sent 
01221      */
01222     if (length < 0x80) {
01223         if (*datalength < 1) {
01224             snprintf(ebuf, sizeof(ebuf),
01225                     "%s: bad length < 1 :%lu, %lu", errpre,
01226                     (unsigned long)*datalength, (unsigned long)length);
01227             ebuf[ sizeof(ebuf)-1 ] = 0;
01228             ERROR_MSG(ebuf);
01229             return NULL;
01230         }
01231         *data++ = (u_char) length;
01232     } else if (length <= 0xFF) {
01233         if (*datalength < 2) {
01234             snprintf(ebuf, sizeof(ebuf),
01235                     "%s: bad length < 2 :%lu, %lu", errpre,
01236                     (unsigned long)*datalength, (unsigned long)length);
01237             ebuf[ sizeof(ebuf)-1 ] = 0;
01238             ERROR_MSG(ebuf);
01239             return NULL;
01240         }
01241         *data++ = (u_char) (0x01 | ASN_LONG_LEN);
01242         *data++ = (u_char) length;
01243     } else {                    /* 0xFF < length <= 0xFFFF */
01244         if (*datalength < 3) {
01245             snprintf(ebuf, sizeof(ebuf),
01246                     "%s: bad length < 3 :%lu, %lu", errpre,
01247                     (unsigned long)*datalength, (unsigned long)length);
01248             ebuf[ sizeof(ebuf)-1 ] = 0;
01249             ERROR_MSG(ebuf);
01250             return NULL;
01251         }
01252         *data++ = (u_char) (0x02 | ASN_LONG_LEN);
01253         *data++ = (u_char) ((length >> 8) & 0xFF);
01254         *data++ = (u_char) (length & 0xFF);
01255     }
01256     *datalength -= (data - start_data);
01257     return data;
01258 
01259 }
01260 
01286 u_char         *
01287 asn_parse_objid(u_char * data,
01288                 size_t * datalength,
01289                 u_char * type, oid * objid, size_t * objidlength)
01290 {
01291     /*
01292      * ASN.1 objid ::= 0x06 asnlength subidentifier {subidentifier}*
01293      * subidentifier ::= {leadingbyte}* lastbyte
01294      * leadingbyte ::= 1 7bitvalue
01295      * lastbyte ::= 0 7bitvalue
01296      */
01297     register u_char *bufp = data;
01298     register oid   *oidp = objid + 1;
01299     register u_long subidentifier;
01300     register long   length;
01301     u_long          asn_length;
01302     size_t          original_length = *objidlength;
01303 
01304     *type = *bufp++;
01305     bufp = asn_parse_length(bufp, &asn_length);
01306     if (_asn_parse_length_check("parse objid", bufp, data,
01307                                 asn_length, *datalength))
01308         return NULL;
01309 
01310     *datalength -= (int) asn_length + (bufp - data);
01311 
01312     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
01313 
01314     /*
01315      * Handle invalid object identifier encodings of the form 06 00 robustly 
01316      */
01317     if (asn_length == 0)
01318         objid[0] = objid[1] = 0;
01319 
01320     length = asn_length;
01321     (*objidlength)--;           /* account for expansion of first byte */
01322 
01323     while (length > 0 && (*objidlength)-- > 0) {
01324         subidentifier = 0;
01325         do {                    /* shift and add in low order 7 bits */
01326             subidentifier =
01327                 (subidentifier << 7) + (*(u_char *) bufp & ~ASN_BIT8);
01328             length--;
01329         } while ((*(u_char *) bufp++ & ASN_BIT8) && (length > 0));        /* last byte has high bit clear */
01330 
01331         if (length == 0) {
01332             u_char *last_byte = bufp - 1;
01333             if (*last_byte & ASN_BIT8) {
01334                 /* last byte has high bit set -> wrong BER encoded OID */
01335                 ERROR_MSG("subidentifier syntax error");
01336                 return NULL;
01337             }
01338         }
01339 #if defined(EIGHTBIT_SUBIDS) || (SIZEOF_LONG != 4)
01340         if (subidentifier > (u_long) MAX_SUBID) {
01341             ERROR_MSG("subidentifier too large");
01342             return NULL;
01343         }
01344 #endif
01345         *oidp++ = (oid) subidentifier;
01346     }
01347 
01348     if (0 != length) {
01349         ERROR_MSG("OID length exceeds buffer size");
01350         *objidlength = original_length;
01351         return NULL;
01352     }
01353 
01354     /*
01355      * The first two subidentifiers are encoded into the first component
01356      * with the value (X * 40) + Y, where:
01357      *  X is the value of the first subidentifier.
01358      *  Y is the value of the second subidentifier.
01359      */
01360     subidentifier = (u_long) objid[1];
01361     if (subidentifier == 0x2B) {
01362         objid[0] = 1;
01363         objid[1] = 3;
01364     } else {
01365         if (subidentifier < 40) {
01366             objid[0] = 0;
01367             objid[1] = subidentifier;
01368         } else if (subidentifier < 80) {
01369             objid[0] = 1;
01370             objid[1] = subidentifier - 40;
01371         } else {
01372             objid[0] = 2;
01373             objid[1] = subidentifier - 80;
01374         }
01375     }
01376 
01377     *objidlength = (int) (oidp - objid);
01378 
01379     DEBUGMSG(("dumpv_recv", "  ObjID: "));
01380     DEBUGMSGOID(("dumpv_recv", objid, *objidlength));
01381     DEBUGMSG(("dumpv_recv", "\n"));
01382     return bufp;
01383 }
01384 
01408 u_char         *
01409 asn_build_objid(u_char * data,
01410                 size_t * datalength,
01411                 u_char type, oid * objid, size_t objidlength)
01412 {
01413     /*
01414      * ASN.1 objid ::= 0x06 asnlength subidentifier {subidentifier}*
01415      * subidentifier ::= {leadingbyte}* lastbyte
01416      * leadingbyte ::= 1 7bitvalue
01417      * lastbyte ::= 0 7bitvalue
01418      */
01419     size_t          asnlength;
01420     register oid   *op = objid;
01421     u_char          objid_size[MAX_OID_LEN];
01422     register u_long objid_val;
01423     u_long          first_objid_val;
01424     register int    i;
01425 #ifndef NETSNMP_NO_DEBUGGING
01426     u_char         *initdatap = data;
01427 #endif
01428 
01429     /*
01430      * check if there are at least 2 sub-identifiers 
01431      */
01432     if (objidlength == 0) {
01433         /*
01434          * there are not, so make OID have two with value of zero 
01435          */
01436         objid_val = 0;
01437         objidlength = 2;
01438     } else if (objid[0] > 2) {
01439         ERROR_MSG("build objid: bad first subidentifier");
01440         return NULL;
01441     } else if (objidlength == 1) {
01442         /*
01443          * encode the first value 
01444          */
01445         objid_val = (op[0] * 40);
01446         objidlength = 2;
01447         op++;
01448     } else {
01449         /*
01450          * combine the first two values 
01451          */
01452         if ((op[1] > 40) &&
01453             (op[0] < 2)) {
01454             ERROR_MSG("build objid: bad second subidentifier");
01455             return NULL;
01456         }
01457         objid_val = (op[0] * 40) + op[1];
01458         op += 2;
01459     }
01460     first_objid_val = objid_val;
01461 
01462     /*
01463      * ditch illegal calls now 
01464      */
01465     if (objidlength > MAX_OID_LEN)
01466         return NULL;
01467 
01468     /*
01469      * calculate the number of bytes needed to store the encoded value 
01470      */
01471     for (i = 1, asnlength = 0;;) {
01472 
01473         CHECK_OVERFLOW_U(objid_val,5);
01474         if (objid_val < (unsigned) 0x80) {
01475             objid_size[i] = 1;
01476             asnlength += 1;
01477         } else if (objid_val < (unsigned) 0x4000) {
01478             objid_size[i] = 2;
01479             asnlength += 2;
01480         } else if (objid_val < (unsigned) 0x200000) {
01481             objid_size[i] = 3;
01482             asnlength += 3;
01483         } else if (objid_val < (unsigned) 0x10000000) {
01484             objid_size[i] = 4;
01485             asnlength += 4;
01486         } else {
01487             objid_size[i] = 5;
01488             asnlength += 5;
01489         }
01490         i++;
01491         if (i >= (int) objidlength)
01492             break;
01493         objid_val = *op++;      /* XXX - doesn't handle 2.X (X > 40) */
01494     }
01495 
01496     /*
01497      * store the ASN.1 tag and length 
01498      */
01499     data = asn_build_header(data, datalength, type, asnlength);
01500     if (_asn_build_header_check
01501         ("build objid", data, *datalength, asnlength))
01502         return NULL;
01503 
01504     /*
01505      * store the encoded OID value 
01506      */
01507     for (i = 1, objid_val = first_objid_val, op = objid + 2;
01508          i < (int) objidlength; i++) {
01509         if (i != 1) {
01510             objid_val = *op++;
01511 #if SIZEOF_LONG != 4
01512             if (objid_val > 0xffffffff) /* already logged warning above */
01513                 objid_val &= 0xffffffff;
01514 #endif
01515         }
01516         switch (objid_size[i]) {
01517         case 1:
01518             *data++ = (u_char) objid_val;
01519             break;
01520 
01521         case 2:
01522             *data++ = (u_char) ((objid_val >> 7) | 0x80);
01523             *data++ = (u_char) (objid_val & 0x07f);
01524             break;
01525 
01526         case 3:
01527             *data++ = (u_char) ((objid_val >> 14) | 0x80);
01528             *data++ = (u_char) ((objid_val >> 7 & 0x7f) | 0x80);
01529             *data++ = (u_char) (objid_val & 0x07f);
01530             break;
01531 
01532         case 4:
01533             *data++ = (u_char) ((objid_val >> 21) | 0x80);
01534             *data++ = (u_char) ((objid_val >> 14 & 0x7f) | 0x80);
01535             *data++ = (u_char) ((objid_val >> 7 & 0x7f) | 0x80);
01536             *data++ = (u_char) (objid_val & 0x07f);
01537             break;
01538 
01539         case 5:
01540             *data++ = (u_char) ((objid_val >> 28) | 0x80);
01541             *data++ = (u_char) ((objid_val >> 21 & 0x7f) | 0x80);
01542             *data++ = (u_char) ((objid_val >> 14 & 0x7f) | 0x80);
01543             *data++ = (u_char) ((objid_val >> 7 & 0x7f) | 0x80);
01544             *data++ = (u_char) (objid_val & 0x07f);
01545             break;
01546         }
01547     }
01548 
01549     /*
01550      * return the length and data ptr 
01551      */
01552     *datalength -= asnlength;
01553     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
01554     DEBUGMSG(("dumpv_send", "  ObjID: "));
01555     DEBUGMSGOID(("dumpv_send", objid, objidlength));
01556     DEBUGMSG(("dumpv_send", "\n"));
01557     return data;
01558 }
01559 
01579 u_char         *
01580 asn_parse_null(u_char * data, size_t * datalength, u_char * type)
01581 {
01582     /*
01583      * ASN.1 null ::= 0x05 0x00
01584      */
01585     register u_char *bufp = data;
01586     u_long          asn_length;
01587 
01588     *type = *bufp++;
01589     bufp = asn_parse_length(bufp, &asn_length);
01590     if (bufp == NULL) {
01591         ERROR_MSG("parse null: bad length");
01592         return NULL;
01593     }
01594     if (asn_length != 0) {
01595         ERROR_MSG("parse null: malformed ASN.1 null");
01596         return NULL;
01597     }
01598 
01599     *datalength -= (bufp - data);
01600 
01601     DEBUGDUMPSETUP("recv", data, bufp - data);
01602     DEBUGMSG(("dumpv_recv", "  NULL\n"));
01603 
01604     return bufp + asn_length;
01605 }
01606 
01607 
01628 u_char         *
01629 asn_build_null(u_char * data, size_t * datalength, u_char type)
01630 {
01631     /*
01632      * ASN.1 null ::= 0x05 0x00
01633      */
01634 #ifndef NETSNMP_NO_DEBUGGING
01635     u_char         *initdatap = data;
01636 #endif
01637     data = asn_build_header(data, datalength, type, 0);
01638     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
01639     DEBUGMSG(("dumpv_send", "  NULL\n"));
01640     return data;
01641 }
01642 
01666 u_char         *
01667 asn_parse_bitstring(u_char * data,
01668                     size_t * datalength,
01669                     u_char * type, u_char * str, size_t * strlength)
01670 {
01671     /*
01672      * bitstring ::= 0x03 asnlength unused {byte}*
01673      */
01674     static const char *errpre = "parse bitstring";
01675     register u_char *bufp = data;
01676     u_long          asn_length;
01677 
01678     *type = *bufp++;
01679     bufp = asn_parse_length(bufp, &asn_length);
01680     if (_asn_parse_length_check(errpre, bufp, data,
01681                                 asn_length, *datalength))
01682         return NULL;
01683 
01684     if ((size_t) asn_length > *strlength) {
01685         _asn_length_err(errpre, (size_t) asn_length, *strlength);
01686         return NULL;
01687     }
01688     if (_asn_bitstring_check(errpre, asn_length, *bufp))
01689         return NULL;
01690 
01691     DEBUGDUMPSETUP("recv", data, bufp - data);
01692     DEBUGMSG(("dumpv_recv", "  Bitstring: "));
01693     DEBUGMSGHEX(("dumpv_recv", data, asn_length));
01694     DEBUGMSG(("dumpv_recv", "\n"));
01695 
01696     memmove(str, bufp, asn_length);
01697     *strlength = (int) asn_length;
01698     *datalength -= (int) asn_length + (bufp - data);
01699     return bufp + asn_length;
01700 }
01701 
01702 
01725 u_char         *
01726 asn_build_bitstring(u_char * data,
01727                     size_t * datalength,
01728                     u_char type, const u_char * str, size_t strlength)
01729 {
01730     /*
01731      * ASN.1 bit string ::= 0x03 asnlength unused {byte}*
01732      */
01733     static const char *errpre = "build bitstring";
01734     if (_asn_bitstring_check
01735         (errpre, strlength, (u_char)((str) ? *str :  0)))
01736         return NULL;
01737 
01738     data = asn_build_header(data, datalength, type, strlength);
01739     if (_asn_build_header_check(errpre, data, *datalength, strlength))
01740         return NULL;
01741 
01742     if (strlength > 0 && str)
01743         memmove(data, str, strlength);
01744     else if (strlength > 0 && !str) {
01745         ERROR_MSG("no string passed into asn_build_bitstring\n");
01746         return NULL;
01747     }
01748 
01749     *datalength -= strlength;
01750     DEBUGDUMPSETUP("send", data, strlength);
01751     DEBUGMSG(("dumpv_send", "  Bitstring: "));
01752     DEBUGMSGHEX(("dumpv_send", data, strlength));
01753     DEBUGMSG(("dumpv_send", "\n"));
01754     return data + strlength;
01755 }
01756 
01779 u_char         *
01780 asn_parse_unsigned_int64(u_char * data,
01781                          size_t * datalength,
01782                          u_char * type,
01783                          struct counter64 * cp, size_t countersize)
01784 {
01785     /*
01786      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
01787      */
01788     static const char *errpre = "parse uint64";
01789     const int       uint64sizelimit = (4 * 2) + 1;
01790     register u_char *bufp = data;
01791     u_long          asn_length;
01792     register u_long low = 0, high = 0;
01793 
01794     if (countersize != sizeof(struct counter64)) {
01795         _asn_size_err(errpre, countersize, sizeof(struct counter64));
01796         return NULL;
01797     }
01798     *type = *bufp++;
01799     bufp = asn_parse_length(bufp, &asn_length);
01800     if (_asn_parse_length_check
01801         (errpre, bufp, data, asn_length, *datalength))
01802         return NULL;
01803 
01804     DEBUGDUMPSETUP("recv", data, bufp - data);
01805 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
01806     /*
01807      * 64 bit counters as opaque 
01808      */
01809     if ((*type == ASN_OPAQUE) &&
01810         (asn_length <= ASN_OPAQUE_COUNTER64_MX_BER_LEN) &&
01811         (*bufp == ASN_OPAQUE_TAG1) &&
01812         ((*(bufp + 1) == ASN_OPAQUE_COUNTER64) ||
01813          (*(bufp + 1) == ASN_OPAQUE_U64))) {
01814         /*
01815          * change type to Counter64 or U64 
01816          */
01817         *type = *(bufp + 1);
01818         /*
01819          * value is encoded as special format 
01820          */
01821         bufp = asn_parse_length(bufp + 2, &asn_length);
01822         if (_asn_parse_length_check("parse opaque uint64", bufp, data,
01823                                     asn_length, *datalength))
01824             return NULL;
01825     }
01826 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
01827     if (((int) asn_length > uint64sizelimit) ||
01828         (((int) asn_length == uint64sizelimit) && *bufp != 0x00)) {
01829         _asn_length_err(errpre, (size_t) asn_length, uint64sizelimit);
01830         return NULL;
01831     }
01832     *datalength -= (int) asn_length + (bufp - data);
01833     if (*bufp & 0x80) {
01834         low = 0xFFFFFF;     /* first byte bit 1 means start the data with 1s */
01835         high = 0xFFFFFF;
01836     }
01837 
01838     while (asn_length--) {
01839         high = ((0x00FFFFFF & high) << 8) | ((low & 0xFF000000) >> 24);
01840         low = ((low & 0x00FFFFFF) << 8) | *bufp++;
01841     }
01842 
01843     CHECK_OVERFLOW_U(high,6);
01844     CHECK_OVERFLOW_U(low,6);
01845 
01846     cp->low = low;
01847     cp->high = high;
01848 
01849     DEBUGIF("dumpv_recv") {
01850         char            i64buf[I64CHARSZ + 1];
01851         printU64(i64buf, cp);
01852         DEBUGMSG(("dumpv_recv", "Counter64: %s", i64buf));
01853     }
01854 
01855     return bufp;
01856 }
01857 
01858 
01880 u_char         *
01881 asn_build_unsigned_int64(u_char * data,
01882                          size_t * datalength,
01883                          u_char type,
01884                          const struct counter64 * cp, size_t countersize)
01885 {
01886     /*
01887      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
01888      */
01889 
01890     register u_long low, high;
01891     register u_long mask, mask2;
01892     int             add_null_byte = 0;
01893     size_t          intsize;
01894 #ifndef NETSNMP_NO_DEBUGGING
01895     u_char         *initdatap = data;
01896 #endif
01897 
01898     if (countersize != sizeof(struct counter64)) {
01899         _asn_size_err("build uint64", countersize,
01900                       sizeof(struct counter64));
01901         return NULL;
01902     }
01903     intsize = 8;
01904     low = cp->low;
01905     high = cp->high;
01906 
01907     CHECK_OVERFLOW_U(high,7);
01908     CHECK_OVERFLOW_U(low,7);
01909 
01910     mask = ((u_long) 0xFF) << (8 * (sizeof(long) - 1));
01911     /*
01912      * mask is 0xFF000000 on a big-endian machine 
01913      */
01914     if ((u_char) ((high & mask) >> (8 * (sizeof(long) - 1))) & 0x80) {
01915         /*
01916          * if MSB is set 
01917          */
01918         add_null_byte = 1;
01919         intsize++;
01920     } else {
01921         /*
01922          * Truncate "unnecessary" bytes off of the most significant end of this 2's
01923          * complement integer.
01924          * There should be no sequence of 9 consecutive 1's or 0's at the most
01925          * significant end of the integer.
01926          */
01927         mask2 = ((u_long) 0x1FF) << ((8 * (sizeof(long) - 1)) - 1);
01928         /*
01929          * mask2 is 0xFF800000 on a big-endian machine 
01930          */
01931         while ((((high & mask2) == 0) || ((high & mask2) == mask2))
01932                && intsize > 1) {
01933             intsize--;
01934             high = (high << 8)
01935                 | ((low & mask) >> (8 * (sizeof(long) - 1)));
01936             low <<= 8;
01937         }
01938     }
01939 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
01940     /*
01941      * encode a Counter64 as an opaque (it also works in SNMPv1) 
01942      */
01943     /*
01944      * turn into Opaque holding special tagged value 
01945      */
01946     if (type == ASN_OPAQUE_COUNTER64) {
01947         /*
01948          * put the tag and length for the Opaque wrapper 
01949          */
01950         data = asn_build_header(data, datalength, ASN_OPAQUE, intsize + 3);
01951         if (_asn_build_header_check
01952             ("build counter u64", data, *datalength, intsize + 3))
01953             return NULL;
01954 
01955         /*
01956          * put the special tag and length 
01957          */
01958         *data++ = ASN_OPAQUE_TAG1;
01959         *data++ = ASN_OPAQUE_COUNTER64;
01960         *data++ = (u_char) intsize;
01961         *datalength = *datalength - 3;
01962     } else
01963         /*
01964          * Encode the Unsigned int64 in an opaque 
01965          */
01966         /*
01967          * turn into Opaque holding special tagged value 
01968          */
01969     if (type == ASN_OPAQUE_U64) {
01970         /*
01971          * put the tag and length for the Opaque wrapper 
01972          */
01973         data = asn_build_header(data, datalength, ASN_OPAQUE, intsize + 3);
01974         if (_asn_build_header_check
01975             ("build opaque u64", data, *datalength, intsize + 3))
01976             return NULL;
01977 
01978         /*
01979          * put the special tag and length 
01980          */
01981         *data++ = ASN_OPAQUE_TAG1;
01982         *data++ = ASN_OPAQUE_U64;
01983         *data++ = (u_char) intsize;
01984         *datalength = *datalength - 3;
01985     } else {
01986 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
01987         data = asn_build_header(data, datalength, type, intsize);
01988         if (_asn_build_header_check
01989             ("build uint64", data, *datalength, intsize))
01990             return NULL;
01991 
01992 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
01993     }
01994 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
01995     *datalength -= intsize;
01996     if (add_null_byte == 1) {
01997         *data++ = '\0';
01998         intsize--;
01999     }
02000     while (intsize--) {
02001         *data++ = (u_char) ((high & mask) >> (8 * (sizeof(long) - 1)));
02002         high = (high << 8)
02003             | ((low & mask) >> (8 * (sizeof(long) - 1)));
02004         low <<= 8;
02005 
02006     }
02007     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
02008     DEBUGIF("dumpv_send") {
02009         char            i64buf[I64CHARSZ + 1];
02010         printU64(i64buf, cp);
02011         DEBUGMSG(("dumpv_send", "%s", i64buf));
02012     }
02013     return data;
02014 }
02015 
02016 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
02017 
02018 
02042 u_char         *
02043 asn_parse_signed_int64(u_char * data,
02044                        size_t * datalength,
02045                        u_char * type,
02046                        struct counter64 * cp, size_t countersize)
02047 {
02048     static const char *errpre = "parse int64";
02049     const int       int64sizelimit = (4 * 2) + 1;
02050     char            ebuf[128];
02051     register u_char *bufp = data;
02052     u_long          asn_length;
02053     register u_int  low = 0, high = 0;
02054 
02055     if (countersize != sizeof(struct counter64)) {
02056         _asn_size_err(errpre, countersize, sizeof(struct counter64));
02057         return NULL;
02058     }
02059     *type = *bufp++;
02060     bufp = asn_parse_length(bufp, &asn_length);
02061     if (_asn_parse_length_check
02062         (errpre, bufp, data, asn_length, *datalength))
02063         return NULL;
02064 
02065     DEBUGDUMPSETUP("recv", data, bufp - data);
02066     if ((*type == ASN_OPAQUE) &&
02067         (asn_length <= ASN_OPAQUE_COUNTER64_MX_BER_LEN) &&
02068         (*bufp == ASN_OPAQUE_TAG1) && (*(bufp + 1) == ASN_OPAQUE_I64)) {
02069         /*
02070          * change type to Int64 
02071          */
02072         *type = *(bufp + 1);
02073         /*
02074          * value is encoded as special format 
02075          */
02076         bufp = asn_parse_length(bufp + 2, &asn_length);
02077         if (_asn_parse_length_check("parse opaque int64", bufp, data,
02078                                     asn_length, *datalength))
02079             return NULL;
02080     }
02081     /*
02082      * this should always have been true until snmp gets int64 PDU types 
02083      */
02084     else {
02085         snprintf(ebuf, sizeof(ebuf),
02086                 "%s: wrong type: %d, len %d, buf bytes (%02X,%02X)",
02087                 errpre, *type, (int) asn_length, *bufp, *(bufp + 1));
02088         ebuf[ sizeof(ebuf)-1 ] = 0;
02089         ERROR_MSG(ebuf);
02090         return NULL;
02091     }
02092     if (((int) asn_length > int64sizelimit) ||
02093         (((int) asn_length == int64sizelimit) && *bufp != 0x00)) {
02094         _asn_length_err(errpre, (size_t) asn_length, int64sizelimit);
02095         return NULL;
02096     }
02097     *datalength -= (int) asn_length + (bufp - data);
02098     if (*bufp & 0x80) {
02099         low = 0xFFFFFF;     /* first byte bit 1 means start the data with 1s */
02100         high = 0xFFFFFF;
02101     }
02102 
02103     while (asn_length--) {
02104         high = ((0x00FFFFFF & high) << 8) | ((low & 0xFF000000) >> 24);
02105         low = ((low & 0x00FFFFFF) << 8) | *bufp++;
02106     }
02107 
02108     CHECK_OVERFLOW_U(high,8);
02109     CHECK_OVERFLOW_U(low,8);
02110 
02111     cp->low = low;
02112     cp->high = high;
02113 
02114     DEBUGIF("dumpv_recv") {
02115         char            i64buf[I64CHARSZ + 1];
02116         printI64(i64buf, cp);
02117         DEBUGMSG(("dumpv_recv", "Integer64: %s", i64buf));
02118     }
02119 
02120     return bufp;
02121 }
02122 
02123 
02124 
02146 u_char         *
02147 asn_build_signed_int64(u_char * data,
02148                        size_t * datalength,
02149                        u_char type,
02150                        const struct counter64 * cp, size_t countersize)
02151 {
02152     /*
02153      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
02154      */
02155 
02156     struct counter64 c64;
02157     register u_int  mask, mask2;
02158     u_long          low, high;
02159     size_t          intsize;
02160 #ifndef NETSNMP_NO_DEBUGGING
02161     u_char         *initdatap = data;
02162 #endif
02163 
02164     if (countersize != sizeof(struct counter64)) {
02165         _asn_size_err("build int64", countersize,
02166                       sizeof(struct counter64));
02167         return NULL;
02168     }
02169     intsize = 8;
02170     memcpy(&c64, cp, sizeof(struct counter64)); /* we're may modify it */
02171     low = c64.low;
02172     high = c64.high;
02173 
02174     CHECK_OVERFLOW_S(high,9);
02175     CHECK_OVERFLOW_U(low,9);
02176 
02177     /*
02178      * Truncate "unnecessary" bytes off of the most significant end of this
02179      * 2's complement integer.  There should be no sequence of 9
02180      * consecutive 1's or 0's at the most significant end of the
02181      * integer.
02182      */
02183     mask = ((u_int) 0xFF) << (8 * (sizeof(u_int) - 1));
02184     mask2 = ((u_int) 0x1FF) << ((8 * (sizeof(u_int) - 1)) - 1);
02185     /*
02186      * mask is 0xFF800000 on a big-endian machine 
02187      */
02188     while ((((high & mask2) == 0) || ((high & mask2) == mask2))
02189            && intsize > 1) {
02190         intsize--;
02191         high = (high << 8)
02192             | ((low & mask) >> (8 * (sizeof(u_int) - 1)));
02193         low <<= 8;
02194     }
02195     /*
02196      * until a real int64 gets incorperated into SNMP, we are going to
02197      * encode it as an opaque instead.  First, we build the opaque
02198      * header and then the int64 tag type we use to mark it as an
02199      * int64 in the opaque string. 
02200      */
02201     data = asn_build_header(data, datalength, ASN_OPAQUE, intsize + 3);
02202     if (_asn_build_header_check
02203         ("build int64", data, *datalength, intsize + 3))
02204         return NULL;
02205 
02206     *data++ = ASN_OPAQUE_TAG1;
02207     *data++ = ASN_OPAQUE_I64;
02208     *data++ = (u_char) intsize;
02209     *datalength -= (3 + intsize);
02210 
02211     while (intsize--) {
02212         *data++ = (u_char) ((high & mask) >> (8 * (sizeof(u_int) - 1)));
02213         high = (high << 8)
02214             | ((low & mask) >> (8 * (sizeof(u_int) - 1)));
02215         low <<= 8;
02216     }
02217     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
02218     DEBUGIF("dumpv_send") {
02219         char            i64buf[I64CHARSZ + 1];
02220         printU64(i64buf, cp);
02221         DEBUGMSG(("dumpv_send", "%s", i64buf));
02222     }
02223     return data;
02224 }
02225 
02226 
02248 u_char         *
02249 asn_parse_float(u_char * data,
02250                 size_t * datalength,
02251                 u_char * type, float *floatp, size_t floatsize)
02252 {
02253     register u_char *bufp = data;
02254     u_long          asn_length;
02255     union {
02256         float           floatVal;
02257         long            longVal;
02258         u_char          c[sizeof(float)];
02259     } fu;
02260 
02261     if (floatsize != sizeof(float)) {
02262         _asn_size_err("parse float", floatsize, sizeof(float));
02263         return NULL;
02264     }
02265     *type = *bufp++;
02266     bufp = asn_parse_length(bufp, &asn_length);
02267     if (_asn_parse_length_check("parse float", bufp, data,
02268                                 asn_length, *datalength))
02269         return NULL;
02270 
02271     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
02272     /*
02273      * the float is encoded as an opaque 
02274      */
02275     if ((*type == ASN_OPAQUE) &&
02276         (asn_length == ASN_OPAQUE_FLOAT_BER_LEN) &&
02277         (*bufp == ASN_OPAQUE_TAG1) && (*(bufp + 1) == ASN_OPAQUE_FLOAT)) {
02278 
02279         /*
02280          * value is encoded as special format 
02281          */
02282         bufp = asn_parse_length(bufp + 2, &asn_length);
02283         if (_asn_parse_length_check("parse opaque float", bufp, data,
02284                                     asn_length, *datalength))
02285             return NULL;
02286 
02287         /*
02288          * change type to Float 
02289          */
02290         *type = ASN_OPAQUE_FLOAT;
02291     }
02292 
02293     if (asn_length != sizeof(float)) {
02294         _asn_size_err("parse seq float", asn_length, sizeof(float));
02295         return NULL;
02296     }
02297 
02298     *datalength -= (int) asn_length + (bufp - data);
02299     memcpy(&fu.c[0], bufp, asn_length);
02300 
02301     /*
02302      * correct for endian differences 
02303      */
02304     fu.longVal = ntohl(fu.longVal);
02305 
02306     *floatp = fu.floatVal;
02307 
02308     DEBUGMSG(("dumpv_recv", "Opaque float: %f\n", *floatp));
02309     return bufp;
02310 }
02311 
02335 u_char         *
02336 asn_build_float(u_char * data,
02337                 size_t * datalength,
02338                 u_char type, const float *floatp, size_t floatsize)
02339 {
02340     union {
02341         float           floatVal;
02342         int             intVal;
02343         u_char          c[sizeof(float)];
02344     } fu;
02345 #ifndef NETSNMP_NO_DEBUGGING
02346     u_char         *initdatap = data;
02347 #endif
02348 
02349     if (floatsize != sizeof(float)) {
02350         _asn_size_err("build float", floatsize, sizeof(float));
02351         return NULL;
02352     }
02353     /*
02354      * encode the float as an opaque 
02355      */
02356     /*
02357      * turn into Opaque holding special tagged value 
02358      */
02359 
02360     /*
02361      * put the tag and length for the Opaque wrapper 
02362      */
02363     data = asn_build_header(data, datalength, ASN_OPAQUE, floatsize + 3);
02364     if (_asn_build_header_check
02365         ("build float", data, *datalength, (floatsize + 3)))
02366         return NULL;
02367 
02368     /*
02369      * put the special tag and length 
02370      */
02371     *data++ = ASN_OPAQUE_TAG1;
02372     *data++ = ASN_OPAQUE_FLOAT;
02373     *data++ = (u_char) floatsize;
02374     *datalength = *datalength - 3;
02375 
02376     fu.floatVal = *floatp;
02377     /*
02378      * correct for endian differences 
02379      */
02380     fu.intVal = htonl(fu.intVal);
02381 
02382     *datalength -= floatsize;
02383     memcpy(data, &fu.c[0], floatsize);
02384 
02385     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
02386     DEBUGMSG(("dumpv_send", "Opaque float: %f\n", *floatp));
02387     data += floatsize;
02388     return data;
02389 }
02390 
02391 
02413 u_char         *
02414 asn_parse_double(u_char * data,
02415                  size_t * datalength,
02416                  u_char * type, double *doublep, size_t doublesize)
02417 {
02418     register u_char *bufp = data;
02419     u_long          asn_length;
02420     long            tmp;
02421     union {
02422         double          doubleVal;
02423         int             intVal[2];
02424         u_char          c[sizeof(double)];
02425     } fu;
02426 
02427 
02428     if (doublesize != sizeof(double)) {
02429         _asn_size_err("parse double", doublesize, sizeof(double));
02430         return NULL;
02431     }
02432     *type = *bufp++;
02433     bufp = asn_parse_length(bufp, &asn_length);
02434     if (_asn_parse_length_check("parse double", bufp, data,
02435                                 asn_length, *datalength))
02436         return NULL;
02437 
02438     DEBUGDUMPSETUP("recv", data, bufp - data + asn_length);
02439     /*
02440      * the double is encoded as an opaque 
02441      */
02442     if ((*type == ASN_OPAQUE) &&
02443         (asn_length == ASN_OPAQUE_DOUBLE_BER_LEN) &&
02444         (*bufp == ASN_OPAQUE_TAG1) && (*(bufp + 1) == ASN_OPAQUE_DOUBLE)) {
02445 
02446         /*
02447          * value is encoded as special format 
02448          */
02449         bufp = asn_parse_length(bufp + 2, &asn_length);
02450         if (_asn_parse_length_check("parse opaque double", bufp, data,
02451                                     asn_length, *datalength))
02452             return NULL;
02453 
02454         /*
02455          * change type to Double 
02456          */
02457         *type = ASN_OPAQUE_DOUBLE;
02458     }
02459 
02460     if (asn_length != sizeof(double)) {
02461         _asn_size_err("parse seq double", asn_length, sizeof(double));
02462         return NULL;
02463     }
02464     *datalength -= (int) asn_length + (bufp - data);
02465     memcpy(&fu.c[0], bufp, asn_length);
02466 
02467     /*
02468      * correct for endian differences 
02469      */
02470 
02471     tmp = ntohl(fu.intVal[0]);
02472     fu.intVal[0] = ntohl(fu.intVal[1]);
02473     fu.intVal[1] = tmp;
02474 
02475     *doublep = fu.doubleVal;
02476     DEBUGMSG(("dumpv_recv", "  Opaque Double:\t%f\n", *doublep));
02477 
02478     return bufp;
02479 }
02480 
02481 
02504 u_char         *
02505 asn_build_double(u_char * data,
02506                  size_t * datalength,
02507                  u_char type, const double *doublep, size_t doublesize)
02508 {
02509     long            tmp;
02510     union {
02511         double          doubleVal;
02512         int             intVal[2];
02513         u_char          c[sizeof(double)];
02514     } fu;
02515 #ifndef NETSNMP_NO_DEBUGGING
02516     u_char         *initdatap = data;
02517 #endif
02518 
02519     if (doublesize != sizeof(double)) {
02520         _asn_size_err("build double", doublesize, sizeof(double));
02521         return NULL;
02522     }
02523 
02524     /*
02525      * encode the double as an opaque 
02526      */
02527     /*
02528      * turn into Opaque holding special tagged value 
02529      */
02530 
02531     /*
02532      * put the tag and length for the Opaque wrapper 
02533      */
02534     data = asn_build_header(data, datalength, ASN_OPAQUE, doublesize + 3);
02535     if (_asn_build_header_check
02536         ("build double", data, *datalength, doublesize + 3))
02537         return NULL;
02538 
02539     /*
02540      * put the special tag and length 
02541      */
02542     *data++ = ASN_OPAQUE_TAG1;
02543     *data++ = ASN_OPAQUE_DOUBLE;
02544     *data++ = (u_char) doublesize;
02545     *datalength = *datalength - 3;
02546 
02547     fu.doubleVal = *doublep;
02548     /*
02549      * correct for endian differences 
02550      */
02551     tmp = htonl(fu.intVal[0]);
02552     fu.intVal[0] = htonl(fu.intVal[1]);
02553     fu.intVal[1] = tmp;
02554     *datalength -= doublesize;
02555     memcpy(data, &fu.c[0], doublesize);
02556 
02557     data += doublesize;
02558     DEBUGDUMPSETUP("send", initdatap, data - initdatap);
02559     DEBUGMSG(("dumpv_send", "  Opaque double: %f", *doublep));
02560     return data;
02561 }
02562 
02563 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
02564 
02565 
02580 int
02581 asn_realloc(u_char ** pkt, size_t * pkt_len)
02582 {
02583     if (pkt != NULL && pkt_len != NULL) {
02584         size_t          old_pkt_len = *pkt_len;
02585 
02586         DEBUGMSGTL(("asn_realloc", " old_pkt %8p, old_pkt_len %lu\n",
02587                     *pkt, (unsigned long)old_pkt_len));
02588 
02589         if (snmp_realloc(pkt, pkt_len)) {
02590             DEBUGMSGTL(("asn_realloc", " new_pkt %8p, new_pkt_len %lu\n",
02591                         *pkt, (unsigned long)*pkt_len));
02592             DEBUGMSGTL(("asn_realloc",
02593                         " memmove(%8p + %08x, %8p, %08x)\n",
02594                         *pkt, (unsigned)(*pkt_len - old_pkt_len),
02595                         *pkt, (unsigned)old_pkt_len));
02596             memmove(*pkt + (*pkt_len - old_pkt_len), *pkt, old_pkt_len);
02597             memset(*pkt, (int) ' ', *pkt_len - old_pkt_len);
02598             return 1;
02599         } else {
02600             DEBUGMSG(("asn_realloc", " CANNOT REALLOC()\n"));
02601         }
02602     }
02603     return 0;
02604 }
02605 
02606 #ifdef NETSNMP_USE_REVERSE_ASNENCODING
02607 
02622 int
02623 asn_realloc_rbuild_length(u_char ** pkt, size_t * pkt_len,
02624                           size_t * offset, int r, size_t length)
02625 {
02626     static const char *errpre = "build length";
02627     char            ebuf[128];
02628     int             tmp_int;
02629     size_t          start_offset = *offset;
02630 
02631     if (length <= 0x7f) {
02632         if (((*pkt_len - *offset) < 1)
02633             && !(r && asn_realloc(pkt, pkt_len))) {
02634             snprintf(ebuf, sizeof(ebuf),
02635                     "%s: bad length < 1 :%ld, %lu", errpre,
02636                     (long)(*pkt_len - *offset), (unsigned long)length);
02637             ebuf[ sizeof(ebuf)-1 ] = 0;
02638             ERROR_MSG(ebuf);
02639             return 0;
02640         }
02641         *(*pkt + *pkt_len - (++*offset)) = length;
02642     } else {
02643         while (length > 0xff) {
02644             if (((*pkt_len - *offset) < 1)
02645                 && !(r && asn_realloc(pkt, pkt_len))) {
02646                 snprintf(ebuf, sizeof(ebuf),
02647                         "%s: bad length < 1 :%ld, %lu", errpre,
02648                         (long)(*pkt_len - *offset), (unsigned long)length);
02649                 ebuf[ sizeof(ebuf)-1 ] = 0;
02650                 ERROR_MSG(ebuf);
02651                 return 0;
02652             }
02653             *(*pkt + *pkt_len - (++*offset)) = length & 0xff;
02654             length >>= 8;
02655         }
02656 
02657         while ((*pkt_len - *offset) < 2) {
02658             if (!(r && asn_realloc(pkt, pkt_len))) {
02659                 snprintf(ebuf, sizeof(ebuf),
02660                         "%s: bad length < 1 :%ld, %lu", errpre,
02661                         (long)(*pkt_len - *offset), (unsigned long)length);
02662                 ebuf[ sizeof(ebuf)-1 ] = 0;
02663                 ERROR_MSG(ebuf);
02664                 return 0;
02665             }
02666         }
02667 
02668         *(*pkt + *pkt_len - (++*offset)) = length & 0xff;
02669         tmp_int = *offset - start_offset;
02670         *(*pkt + *pkt_len - (++*offset)) = tmp_int | 0x80;
02671     }
02672 
02673     return 1;
02674 }
02675 
02693 int
02694 asn_realloc_rbuild_header(u_char ** pkt, size_t * pkt_len,
02695                           size_t * offset, int r,
02696                           u_char type, size_t length)
02697 {
02698     char            ebuf[128];
02699 
02700     if (asn_realloc_rbuild_length(pkt, pkt_len, offset, r, length)) {
02701         if (((*pkt_len - *offset) < 1)
02702             && !(r && asn_realloc(pkt, pkt_len))) {
02703             snprintf(ebuf, sizeof(ebuf),
02704                     "bad header length < 1 :%ld, %lu",
02705                     (long)(*pkt_len - *offset), (unsigned long)length);
02706             ebuf[ sizeof(ebuf)-1 ] = 0;
02707             ERROR_MSG(ebuf);
02708             return 0;
02709         }
02710         *(*pkt + *pkt_len - (++*offset)) = type;
02711         return 1;
02712     }
02713     return 0;
02714 }
02715 
02733 int
02734 asn_realloc_rbuild_int(u_char ** pkt, size_t * pkt_len,
02735                        size_t * offset, int r,
02736                        u_char type, const long *intp, size_t intsize)
02737 {
02738     static const char *errpre = "build int";
02739     register long   integer = *intp;
02740     int             testvalue;
02741     size_t          start_offset = *offset;
02742 
02743     if (intsize != sizeof(long)) {
02744         _asn_size_err(errpre, intsize, sizeof(long));
02745         return 0;
02746     }
02747 
02748     CHECK_OVERFLOW_S(integer,10);
02749     testvalue = (integer < 0) ? -1 : 0;
02750 
02751     if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
02752         return 0;
02753     }
02754     *(*pkt + *pkt_len - (++*offset)) = (u_char) integer;
02755     integer >>= 8;
02756 
02757     while (integer != testvalue) {
02758         if (((*pkt_len - *offset) < 1)
02759             && !(r && asn_realloc(pkt, pkt_len))) {
02760             return 0;
02761         }
02762         *(*pkt + *pkt_len - (++*offset)) = (u_char) integer;
02763         integer >>= 8;
02764     }
02765 
02766     if ((*(*pkt + *pkt_len - *offset) & 0x80) != (testvalue & 0x80)) {
02767         /*
02768          * Make sure left most bit is representational of the rest of the bits
02769          * that aren't encoded.  
02770          */
02771         if (((*pkt_len - *offset) < 1)
02772             && !(r && asn_realloc(pkt, pkt_len))) {
02773             return 0;
02774         }
02775         *(*pkt + *pkt_len - (++*offset)) = testvalue & 0xff;
02776     }
02777 
02778     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r, type,
02779                                   (*offset - start_offset))) {
02780         if (_asn_realloc_build_header_check(errpre, pkt, pkt_len,
02781                                             (*offset - start_offset))) {
02782             return 0;
02783         } else {
02784             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
02785                            (*offset - start_offset));
02786             DEBUGMSG(("dumpv_send", "  Integer:\t%ld (0x%.2lX)\n", *intp,
02787                       *intp));
02788             return 1;
02789         }
02790     }
02791 
02792     return 0;
02793 }
02794 
02813 int
02814 asn_realloc_rbuild_string(u_char ** pkt, size_t * pkt_len,
02815                           size_t * offset, int r,
02816                           u_char type,
02817                           const u_char * str, size_t strlength)
02818 {
02819     static const char *errpre = "build string";
02820     size_t          start_offset = *offset;
02821 
02822     while ((*pkt_len - *offset) < strlength) {
02823         if (!(r && asn_realloc(pkt, pkt_len))) {
02824             return 0;
02825         }
02826     }
02827 
02828     *offset += strlength;
02829     memcpy(*pkt + *pkt_len - *offset, str, strlength);
02830 
02831     if (asn_realloc_rbuild_header
02832         (pkt, pkt_len, offset, r, type, strlength)) {
02833         if (_asn_realloc_build_header_check
02834             (errpre, pkt, pkt_len, strlength)) {
02835             return 0;
02836         } else {
02837             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
02838                            *offset - start_offset);
02839             DEBUGIF("dumpv_send") {
02840                 if (strlength == 0) {
02841                     DEBUGMSG(("dumpv_send", "  String: [NULL]\n"));
02842                 } else {
02843                     u_char         *buf = (u_char *) malloc(2 * strlength);
02844                     size_t          l =
02845                         (buf != NULL) ? (2 * strlength) : 0, ol = 0;
02846 
02847                     if (sprint_realloc_asciistring
02848                         (&buf, &l, &ol, 1, str, strlength)) {
02849                         DEBUGMSG(("dumpv_send", "  String:\t%s\n", buf));
02850                     } else {
02851                         if (buf == NULL) {
02852                             DEBUGMSG(("dumpv_send",
02853                                       "  String:\t[TRUNCATED]\n"));
02854                         } else {
02855                             DEBUGMSG(("dumpv_send",
02856                                       "  String:\t%s [TRUNCATED]\n", buf));
02857                         }
02858                     }
02859                     if (buf != NULL) {
02860                         free(buf);
02861                     }
02862                 }
02863             }
02864         }
02865         return 1;
02866     }
02867 
02868     return 0;
02869 }
02870 
02888 int
02889 asn_realloc_rbuild_unsigned_int(u_char ** pkt, size_t * pkt_len,
02890                                 size_t * offset, int r,
02891                             u_char type, const u_long * intp, size_t intsize)
02892 {
02893     static const char *errpre = "build uint";
02894     register u_long integer = *intp;
02895     size_t          start_offset = *offset;
02896 
02897     if (intsize != sizeof(unsigned long)) {
02898         _asn_size_err(errpre, intsize, sizeof(unsigned long));
02899         return 0;
02900     }
02901 
02902     CHECK_OVERFLOW_U(integer,11);
02903 
02904     if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
02905         return 0;
02906     }
02907     *(*pkt + *pkt_len - (++*offset)) = (u_char) integer;
02908     integer >>= 8;
02909 
02910     while (integer != 0) {
02911         if (((*pkt_len - *offset) < 1)
02912             && !(r && asn_realloc(pkt, pkt_len))) {
02913             return 0;
02914         }
02915         *(*pkt + *pkt_len - (++*offset)) = (u_char) integer;
02916         integer >>= 8;
02917     }
02918 
02919     if ((*(*pkt + *pkt_len - *offset) & 0x80) != (0 & 0x80)) {
02920         /*
02921          * Make sure left most bit is representational of the rest of the bits
02922          * that aren't encoded.  
02923          */
02924         if (((*pkt_len - *offset) < 1)
02925             && !(r && asn_realloc(pkt, pkt_len))) {
02926             return 0;
02927         }
02928         *(*pkt + *pkt_len - (++*offset)) = 0;
02929     }
02930 
02931     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r, type,
02932                                   (*offset - start_offset))) {
02933         if (_asn_realloc_build_header_check(errpre, pkt, pkt_len,
02934                                             (*offset - start_offset))) {
02935             return 0;
02936         } else {
02937             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
02938                            (*offset - start_offset));
02939             DEBUGMSG(("dumpv_send", "  UInteger:\t%lu (0x%.2lX)\n", *intp,
02940                       *intp));
02941             return 1;
02942         }
02943     }
02944 
02945     return 0;
02946 }
02947 
02965 int
02966 asn_realloc_rbuild_sequence(u_char ** pkt, size_t * pkt_len,
02967                             size_t * offset, int r,
02968                             u_char type, size_t length)
02969 {
02970     return asn_realloc_rbuild_header(pkt, pkt_len, offset, r, type,
02971                                      length);
02972 }
02973 
02992 int
02993 asn_realloc_rbuild_objid(u_char ** pkt, size_t * pkt_len,
02994                          size_t * offset, int r,
02995                          u_char type,
02996                          const oid * objid, size_t objidlength)
02997 {
02998     /*
02999      * ASN.1 objid ::= 0x06 asnlength subidentifier {subidentifier}*
03000      * subidentifier ::= {leadingbyte}* lastbyte
03001      * leadingbyte ::= 1 7bitvalue
03002      * lastbyte ::= 0 7bitvalue
03003      */
03004     register size_t i;
03005     register oid    tmpint;
03006     size_t          start_offset = *offset;
03007     const char     *errpre = "build objid";
03008 
03009     /*
03010      * Check if there are at least 2 sub-identifiers.  
03011      */
03012     if (objidlength == 0) {
03013         /*
03014          * There are not, so make OID have two with value of zero.  
03015          */
03016         while ((*pkt_len - *offset) < 2) {
03017             if (!(r && asn_realloc(pkt, pkt_len))) {
03018                 return 0;
03019             }
03020         }
03021 
03022         *(*pkt + *pkt_len - (++*offset)) = 0;
03023         *(*pkt + *pkt_len - (++*offset)) = 0;
03024     } else if (objid[0] > 2) {
03025         ERROR_MSG("build objid: bad first subidentifier");
03026         return 0;
03027     } else if (objidlength == 1) {
03028         /*
03029          * Encode the first value.  
03030          */
03031         if (((*pkt_len - *offset) < 1)
03032             && !(r && asn_realloc(pkt, pkt_len))) {
03033             return 0;
03034         }
03035         *(*pkt + *pkt_len - (++*offset)) = (u_char) objid[0];
03036     } else {
03037         for (i = objidlength; i > 2; i--) {
03038             tmpint = objid[i - 1];
03039             CHECK_OVERFLOW_U(tmpint,12);
03040 
03041             if (((*pkt_len - *offset) < 1)
03042                 && !(r && asn_realloc(pkt, pkt_len))) {
03043                 return 0;
03044             }
03045             *(*pkt + *pkt_len - (++*offset)) = (u_char) tmpint & 0x7f;
03046             tmpint >>= 7;
03047 
03048             while (tmpint > 0) {
03049                 if (((*pkt_len - *offset) < 1)
03050                     && !(r && asn_realloc(pkt, pkt_len))) {
03051                     return 0;
03052                 }
03053                 *(*pkt + *pkt_len - (++*offset)) =
03054                     (u_char) ((tmpint & 0x7f) | 0x80);
03055                 tmpint >>= 7;
03056             }
03057         }
03058 
03059         /*
03060          * Combine the first two values.  
03061          */
03062         if ((objid[1] > 40) &&
03063             (objid[0] < 2)) {
03064             ERROR_MSG("build objid: bad second subidentifier");
03065             return 0;
03066         }
03067         tmpint = ((objid[0] * 40) + objid[1]);
03068         if (((*pkt_len - *offset) < 1)
03069             && !(r && asn_realloc(pkt, pkt_len))) {
03070             return 0;
03071         }
03072         *(*pkt + *pkt_len - (++*offset)) = (u_char) tmpint & 0x7f;
03073         tmpint >>= 7;
03074 
03075         while (tmpint > 0) {
03076             if (((*pkt_len - *offset) < 1)
03077                 && !(r && asn_realloc(pkt, pkt_len))) {
03078                 return 0;
03079             }
03080             *(*pkt + *pkt_len - (++*offset)) =
03081                 (u_char) ((tmpint & 0x7f) | 0x80);
03082             tmpint >>= 7;
03083         }
03084     }
03085 
03086     tmpint = *offset - start_offset;
03087     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r, type,
03088                                   (*offset - start_offset))) {
03089         if (_asn_realloc_build_header_check(errpre, pkt, pkt_len,
03090                                             (*offset - start_offset))) {
03091             return 0;
03092         } else {
03093             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
03094                            (*offset - start_offset));
03095             DEBUGMSG(("dumpv_send", "  ObjID: "));
03096             DEBUGMSGOID(("dumpv_send", objid, objidlength));
03097             DEBUGMSG(("dumpv_send", "\n"));
03098             return 1;
03099         }
03100     }
03101 
03102     return 0;
03103 }
03104 
03121 int
03122 asn_realloc_rbuild_null(u_char ** pkt, size_t * pkt_len,
03123                         size_t * offset, int r, u_char type)
03124 {
03125     /*
03126      * ASN.1 null ::= 0x05 0x00
03127      */
03128     size_t          start_offset = *offset;
03129 
03130     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r, type, 0)) {
03131         DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
03132                        (*offset - start_offset));
03133         DEBUGMSG(("dumpv_send", "  NULL\n"));
03134         return 1;
03135     } else {
03136         return 0;
03137     }
03138 }
03139 
03158 int
03159 asn_realloc_rbuild_bitstring(u_char ** pkt, size_t * pkt_len,
03160                              size_t * offset, int r,
03161                              u_char type,
03162                              const u_char * str, size_t strlength)
03163 {
03164     /*
03165      * ASN.1 bit string ::= 0x03 asnlength unused {byte}*
03166      */
03167     static const char *errpre = "build bitstring";
03168     size_t          start_offset = *offset;
03169 
03170     while ((*pkt_len - *offset) < strlength) {
03171         if (!(r && asn_realloc(pkt, pkt_len))) {
03172             return 0;
03173         }
03174     }
03175 
03176     *offset += strlength;
03177     memcpy(*pkt + *pkt_len - *offset, str, strlength);
03178 
03179     if (asn_realloc_rbuild_header
03180         (pkt, pkt_len, offset, r, type, strlength)) {
03181         if (_asn_realloc_build_header_check
03182             (errpre, pkt, pkt_len, strlength)) {
03183             return 0;
03184         } else {
03185             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
03186                            *offset - start_offset);
03187             DEBUGIF("dumpv_send") {
03188                 if (strlength == 0) {
03189                     DEBUGMSG(("dumpv_send", "  Bitstring: [NULL]\n"));
03190                 } else {
03191                     u_char         *buf = (u_char *) malloc(2 * strlength);
03192                     size_t          l =
03193                         (buf != NULL) ? (2 * strlength) : 0, ol = 0;
03194 
03195                     if (sprint_realloc_asciistring
03196                         (&buf, &l, &ol, 1, str, strlength)) {
03197                         DEBUGMSG(("dumpv_send", "  Bitstring:\t%s\n",
03198                                   buf));
03199                     } else {
03200                         if (buf == NULL) {
03201                             DEBUGMSG(("dumpv_send",
03202                                       "  Bitstring:\t[TRUNCATED]\n"));
03203                         } else {
03204                             DEBUGMSG(("dumpv_send",
03205                                       "  Bitstring:\t%s [TRUNCATED]\n",
03206                                       buf));
03207                         }
03208                     }
03209                     if (buf != NULL) {
03210                         free(buf);
03211                     }
03212                 }
03213             }
03214         }
03215         return 1;
03216     }
03217 
03218     return 0;
03219 }
03220 
03238 int
03239 asn_realloc_rbuild_unsigned_int64(u_char ** pkt, size_t * pkt_len,
03240                                   size_t * offset, int r,
03241                                   u_char type,
03242                                const struct counter64 *cp, size_t countersize)
03243 {
03244     /*
03245      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
03246      */
03247     register u_long low = cp->low, high = cp->high;
03248     size_t          intsize, start_offset = *offset;
03249     int             count;
03250 
03251     if (countersize != sizeof(struct counter64)) {
03252         _asn_size_err("build uint64", countersize,
03253                       sizeof(struct counter64));
03254         return 0;
03255     }
03256 
03257     CHECK_OVERFLOW_U(high,13);
03258     CHECK_OVERFLOW_U(low,13);
03259 
03260     /*
03261      * Encode the low 4 bytes first.  
03262      */
03263     if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
03264         return 0;
03265     }
03266     *(*pkt + *pkt_len - (++*offset)) = (u_char) low;
03267     low >>= 8;
03268     count = 1;
03269 
03270     while (low != 0) {
03271         count++;
03272         if (((*pkt_len - *offset) < 1)
03273             && !(r && asn_realloc(pkt, pkt_len))) {
03274             return 0;
03275         }
03276         *(*pkt + *pkt_len - (++*offset)) = (u_char) low;
03277         low >>= 8;
03278     }
03279 
03280     /*
03281      * Then the high byte if present.  
03282      */
03283     if (high) {
03284         /*
03285          * Do the rest of the low byte.  
03286          */
03287         for (; count < 4; count++) {
03288             if (((*pkt_len - *offset) < 1)
03289                 && !(r && asn_realloc(pkt, pkt_len))) {
03290                 return 0;
03291             }
03292             *(*pkt + *pkt_len - (++*offset)) = 0;
03293         }
03294 
03295         /*
03296          * Do high byte.  
03297          */
03298         if (((*pkt_len - *offset) < 1)
03299             && !(r && asn_realloc(pkt, pkt_len))) {
03300             return 0;
03301         }
03302         *(*pkt + *pkt_len - (++*offset)) = (u_char) high;
03303         high >>= 8;
03304 
03305         while (high != 0) {
03306             if (((*pkt_len - *offset) < 1)
03307                 && !(r && asn_realloc(pkt, pkt_len))) {
03308                 return 0;
03309             }
03310             *(*pkt + *pkt_len - (++*offset)) = (u_char) high;
03311             high >>= 8;
03312         }
03313     }
03314 
03315     if ((*(*pkt + *pkt_len - *offset) & 0x80) != (0 & 0x80)) {
03316         /*
03317          * Make sure left most bit is representational of the rest of the bits
03318          * that aren't encoded.  
03319          */
03320         if (((*pkt_len - *offset) < 1)
03321             && !(r && asn_realloc(pkt, pkt_len))) {
03322             return 0;
03323         }
03324         *(*pkt + *pkt_len - (++*offset)) = 0;
03325     }
03326 
03327     intsize = *offset - start_offset;
03328 
03329 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
03330     /*
03331      * Encode a Counter64 as an opaque (it also works in SNMPv1).  
03332      */
03333     if (type == ASN_OPAQUE_COUNTER64) {
03334         while ((*pkt_len - *offset) < 5) {
03335             if (!(r && asn_realloc(pkt, pkt_len))) {
03336                 return 0;
03337             }
03338         }
03339 
03340         *(*pkt + *pkt_len - (++*offset)) = (u_char) intsize;
03341         *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_COUNTER64;
03342         *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_TAG1;
03343 
03344         /*
03345          * Put the tag and length for the Opaque wrapper.  
03346          */
03347         if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r,
03348                                       ASN_OPAQUE, intsize + 3)) {
03349             if (_asn_realloc_build_header_check
03350                 ("build counter u64", pkt, pkt_len, intsize + 3)) {
03351                 return 0;
03352             }
03353         } else {
03354             return 0;
03355         }
03356     } else if (type == ASN_OPAQUE_U64) {
03357         /*
03358          * Encode the Unsigned int64 in an opaque.  
03359          */
03360         while ((*pkt_len - *offset) < 5) {
03361             if (!(r && asn_realloc(pkt, pkt_len))) {
03362                 return 0;
03363             }
03364         }
03365 
03366         *(*pkt + *pkt_len - (++*offset)) = (u_char) intsize;
03367         *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_U64;
03368         *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_TAG1;
03369 
03370         /*
03371          * Put the tag and length for the Opaque wrapper.  
03372          */
03373         if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r,
03374                                       ASN_OPAQUE, intsize + 3)) {
03375             if (_asn_realloc_build_header_check
03376                 ("build counter u64", pkt, pkt_len, intsize + 3)) {
03377                 return 0;
03378             }
03379         } else {
03380             return 0;
03381         }
03382     } else {
03383 
03384 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
03385         if (asn_realloc_rbuild_header
03386             (pkt, pkt_len, offset, r, type, intsize)) {
03387             if (_asn_realloc_build_header_check
03388                 ("build uint64", pkt, pkt_len, intsize)) {
03389                 return 0;
03390             }
03391         } else {
03392             return 0;
03393         }
03394 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
03395     }
03396 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
03397 
03398     DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset), intsize);
03399     DEBUGMSG(("dumpv_send", "  U64:\t%lu %lu\n", cp->high, cp->low));
03400     return 1;
03401 }
03402 
03403 #ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
03404 
03405 
03423 int
03424 asn_realloc_rbuild_signed_int64(u_char ** pkt, size_t * pkt_len,
03425                                 size_t * offset, int r,
03426                                 u_char type,
03427                                 const struct counter64 *cp, size_t countersize)
03428 {
03429     /*
03430      * ASN.1 integer ::= 0x02 asnlength byte {byte}*
03431      */
03432     register long low = cp->low, high = cp->high;
03433     size_t          intsize, start_offset = *offset;
03434     int             count, testvalue = (high & 0x80000000) ? -1 : 0;
03435 
03436     if (countersize != sizeof(struct counter64)) {
03437         _asn_size_err("build uint64", countersize,
03438                       sizeof(struct counter64));
03439         return 0;
03440     }
03441 
03442     CHECK_OVERFLOW_S(high,14);
03443     CHECK_OVERFLOW_U(low,14);
03444 
03445     /*
03446      * Encode the low 4 bytes first.  
03447      */
03448     if (((*pkt_len - *offset) < 1) && !(r && asn_realloc(pkt, pkt_len))) {
03449         return 0;
03450     }
03451     *(*pkt + *pkt_len - (++*offset)) = (u_char) low;
03452     low >>= 8;
03453     count = 1;
03454 
03455     while ((int) low != testvalue && count < 4) {
03456         count++;
03457         if (((*pkt_len - *offset) < 1)
03458             && !(r && asn_realloc(pkt, pkt_len))) {
03459             return 0;
03460         }
03461         *(*pkt + *pkt_len - (++*offset)) = (u_char) low;
03462         low >>= 8;
03463     }
03464 
03465     /*
03466      * Then the high byte if present.  
03467      */
03468     if (high != testvalue) {
03469         /*
03470          * Do the rest of the low byte.  
03471          */
03472         for (; count < 4; count++) {
03473             if (((*pkt_len - *offset) < 1)
03474                 && !(r && asn_realloc(pkt, pkt_len))) {
03475                 return 0;
03476             }
03477             *(*pkt + *pkt_len - (++*offset)) = (testvalue == 0) ? 0 : 0xff;
03478         }
03479 
03480         /*
03481          * Do high byte.  
03482          */
03483         if (((*pkt_len - *offset) < 1)
03484             && !(r && asn_realloc(pkt, pkt_len))) {
03485             return 0;
03486         }
03487         *(*pkt + *pkt_len - (++*offset)) = (u_char) high;
03488         high >>= 8;
03489 
03490         while ((int) high != testvalue) {
03491             if (((*pkt_len - *offset) < 1)
03492                 && !(r && asn_realloc(pkt, pkt_len))) {
03493                 return 0;
03494             }
03495             *(*pkt + *pkt_len - (++*offset)) = (u_char) high;
03496             high >>= 8;
03497         }
03498     }
03499 
03500     if ((*(*pkt + *pkt_len - *offset) & 0x80) != (testvalue & 0x80)) {
03501         /*
03502          * Make sure left most bit is representational of the rest of the bits
03503          * that aren't encoded.  
03504          */
03505         if (((*pkt_len - *offset) < 1)
03506             && !(r && asn_realloc(pkt, pkt_len))) {
03507             return 0;
03508         }
03509         *(*pkt + *pkt_len - (++*offset)) = (testvalue == 0) ? 0 : 0xff;
03510     }
03511 
03512     intsize = *offset - start_offset;
03513 
03514     while ((*pkt_len - *offset) < 5) {
03515         if (!(r && asn_realloc(pkt, pkt_len))) {
03516             return 0;
03517         }
03518     }
03519 
03520     *(*pkt + *pkt_len - (++*offset)) = (u_char) intsize;
03521     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_I64;
03522     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_TAG1;
03523 
03524     /*
03525      * Put the tag and length for the Opaque wrapper.  
03526      */
03527     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r,
03528                                   ASN_OPAQUE, intsize + 3)) {
03529         if (_asn_realloc_build_header_check
03530             ("build counter u64", pkt, pkt_len, intsize + 3)) {
03531             return 0;
03532         }
03533     } else {
03534         return 0;
03535     }
03536 
03537     DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset), intsize);
03538     DEBUGMSG(("dumpv_send", "  UInt64:\t%lu %lu\n", cp->high, cp->low));
03539     return 1;
03540 }
03541 
03560 int
03561 asn_realloc_rbuild_float(u_char ** pkt, size_t * pkt_len,
03562                          size_t * offset, int r,
03563                          u_char type, const float *floatp, size_t floatsize)
03564 {
03565     size_t          start_offset = *offset;
03566     union {
03567         float           floatVal;
03568         int             intVal;
03569         u_char          c[sizeof(float)];
03570     } fu;
03571 
03572     /*
03573      * Floatsize better not be larger than realistic.  
03574      */
03575     if (floatsize != sizeof(float) || floatsize > 122) {
03576         return 0;
03577     }
03578 
03579     while ((*pkt_len - *offset) < floatsize + 3) {
03580         if (!(r && asn_realloc(pkt, pkt_len))) {
03581             return 0;
03582         }
03583     }
03584 
03585     /*
03586      * Correct for endian differences and copy value.  
03587      */
03588     fu.floatVal = *floatp;
03589     fu.intVal = htonl(fu.intVal);
03590     *offset += floatsize;
03591     memcpy(*pkt + *pkt_len - *offset, &(fu.c[0]), floatsize);
03592 
03593     /*
03594      * Put the special tag and length (3 bytes).  
03595      */
03596     *(*pkt + *pkt_len - (++*offset)) = (u_char) floatsize;
03597     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_FLOAT;
03598     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_TAG1;
03599 
03600     /*
03601      * Put the tag and length for the Opaque wrapper.  
03602      */
03603     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r,
03604                                   ASN_OPAQUE, floatsize + 3)) {
03605         if (_asn_realloc_build_header_check("build float", pkt, pkt_len,
03606                                             floatsize + 3)) {
03607             return 0;
03608         } else {
03609             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
03610                            *offset - start_offset);
03611             DEBUGMSG(("dumpv_send", "Opaque Float:\t%f\n", *floatp));
03612             return 1;
03613         }
03614     }
03615 
03616     return 0;
03617 }
03618 
03637 int
03638 asn_realloc_rbuild_double(u_char ** pkt, size_t * pkt_len,
03639                           size_t * offset, int r,
03640                           u_char type, const double *doublep, size_t doublesize)
03641 {
03642     size_t          start_offset = *offset;
03643     long            tmp;
03644     union {
03645         double          doubleVal;
03646         int             intVal[2];
03647         u_char          c[sizeof(double)];
03648     } fu;
03649 
03650     /*
03651      * Doublesize better not be larger than realistic.  
03652      */
03653     if (doublesize != sizeof(double) || doublesize > 122) {
03654         return 0;
03655     }
03656 
03657     while ((*pkt_len - *offset) < doublesize + 3) {
03658         if (!(r && asn_realloc(pkt, pkt_len))) {
03659             return 0;
03660         }
03661     }
03662 
03663     /*
03664      * Correct for endian differences and copy value.  
03665      */
03666     fu.doubleVal = *doublep;
03667     tmp = htonl(fu.intVal[0]);
03668     fu.intVal[0] = htonl(fu.intVal[1]);
03669     fu.intVal[1] = tmp;
03670     *offset += doublesize;
03671     memcpy(*pkt + *pkt_len - *offset, &(fu.c[0]), doublesize);
03672 
03673     /*
03674      * Put the special tag and length (3 bytes).  
03675      */
03676     *(*pkt + *pkt_len - (++*offset)) = (u_char) doublesize;
03677     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_DOUBLE;
03678     *(*pkt + *pkt_len - (++*offset)) = ASN_OPAQUE_TAG1;
03679 
03680     /*
03681      * Put the tag and length for the Opaque wrapper.  
03682      */
03683     if (asn_realloc_rbuild_header(pkt, pkt_len, offset, r,
03684                                   ASN_OPAQUE, doublesize + 3)) {
03685         if (_asn_realloc_build_header_check("build float", pkt, pkt_len,
03686                                             doublesize + 3)) {
03687             return 0;
03688         } else {
03689             DEBUGDUMPSETUP("send", (*pkt + *pkt_len - *offset),
03690                            *offset - start_offset);
03691             DEBUGMSG(("dumpv_send", "  Opaque Double:\t%f\n", *doublep));
03692             return 1;
03693         }
03694     }
03695 
03696     return 0;
03697 }
03698 
03699 #endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
03700 #endif                          /*  NETSNMP_USE_REVERSE_ASNENCODING  */
03701