int
smux_open (int sock)
{
u_char buf[BUFSIZ];
u_char *ptr;
size_t len;
u_long version;
u_char progname[] = QUAGGA_PROGNAME "-" QUAGGA_VERSION;
if (debug_smux)
{
smux_oid_dump ("SMUX open oid", smux_oid, smux_oid_len);
zlog_debug ("SMUX open progname: %s", progname);
zlog_debug ("SMUX open password: %s", smux_passwd);
}
ptr = buf;
len = BUFSIZ;
/* SMUX Header. As placeholder. */
ptr = asn_build_header (ptr, &len, (u_char) SMUX_OPEN, 0);
/* SMUX Open. */
version = 0;
ptr = asn_build_int (ptr, &len,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&version, sizeof (version));
/* SMUX connection oid. */
ptr = asn_build_objid (ptr, &len,
(u_char)
(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
smux_oid, smux_oid_len);
/* SMUX connection description. */
ptr = asn_build_string (ptr, &len,
(u_char)
(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
progname, strlen (progname));
/* SMUX connection password. */
ptr = asn_build_string (ptr, &len,
(u_char)
(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
smux_passwd, strlen (smux_passwd));
/* Fill in real SMUX header. We exclude ASN header size (2). */
len = BUFSIZ;
asn_build_header (buf, &len, (u_char) SMUX_OPEN, (ptr - buf) - 2);
return send (sock, buf, (ptr - buf), 0);
}
/*******************************************************************-o-******
* snmp_comstr_build
*
* Parameters:
* *data
* *length
* *psid
* *slen
* *version
* messagelen
*
* Returns:
* Pointer into 'data' after built section.
*
*
* Build the header of a community string-based message such as that found
* in SNMPv1 and SNMPv2c.
*
* NOTE: The length of the message will have to be inserted later,
* if not known.
*
* NOTE: Version is an 'int'. (CMU had it as a long, but was passing
* in a *int. Grrr.) Assign version to verfix and pass in
* that to asn_build_int instead which expects a long. -- WH
*/
u_char *
snmp_comstr_build(u_char * data,
size_t * length,
u_char * psid,
size_t * slen, long *version, size_t messagelen)
{
long verfix = *version;
u_char *h1 = data;
u_char *h1e;
size_t hlength = *length;
/*
* Build the the message wrapper (note length will be inserted later).
*/
data =
asn_build_sequence(data, length,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR), 0);
if (data == NULL) {
return NULL;
}
h1e = data;
/*
* Store the version field.
*/
data = asn_build_int(data, length,
(u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
ASN_INTEGER), &verfix, sizeof(verfix));
if (data == NULL) {
return NULL;
}
/*
* Store the community string.
*/
data = asn_build_string(data, length,
(u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
ASN_OCTET_STR), psid,
*(u_char *) slen);
if (data == NULL) {
return NULL;
}
/*
* Insert length.
*/
asn_build_sequence(h1, &hlength,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
data - h1e + messagelen);
return data;
} /* end snmp_comstr_build() */
u_char *
snmp_msg_Encode(u_char * Buffer, int *BufLenP,
u_char * Community, int CommLen,
int Version,
struct snmp_pdu *PDU)
{
u_char *bufp, *tmp;
u_char *PDUHeaderPtr, *VARHeaderPtr;
u_char *PDUDataStart, *VARDataStart;
u_char *MsgPtr;
int FakeArg = 1024;
snmplib_debug(4, "Buffer=%p BufLenP=%p, buflen=%d\n", Buffer, BufLenP,
*BufLenP);
/* Header for the entire thing, with a false, large length */
bufp = asn_build_header(Buffer, BufLenP,
(u_char) (ASN_SEQUENCE |
ASN_CONSTRUCTOR),
(*BufLenP));
if (bufp == NULL) {
snmplib_debug(4, "snmp_msg_Encode:Error encoding SNMP Message Header (Header)!\n");
return (NULL);
}
MsgPtr = bufp;
/* Version */
bufp = asn_build_int(bufp, BufLenP,
(u_char) (ASN_UNIVERSAL |
ASN_PRIMITIVE |
ASN_INTEGER),
(int *) (&Version), sizeof(Version));
if (bufp == NULL) {
snmplib_debug(4, "snmp_msg_Encode:Error encoding SNMP Message Header (Version)!\n");
return (NULL);
}
snmplib_debug(8, "snmp_msg_Encode: Encoding community (%s) (%d)\n", Community, CommLen);
/* Community */
bufp = asn_build_string(bufp, BufLenP,
(u_char) (ASN_UNIVERSAL |
ASN_PRIMITIVE |
ASN_OCTET_STR),
Community, CommLen);
if (bufp == NULL) {
snmplib_debug(4, "snmp_msg_Encode:Error encoding SNMP Message Header (Community)!\n");
return (NULL);
}
/* Encode the rest. */
/* A nice header for this PDU.
* Encoded with the wrong length. We'll fix it later.
*/
snmplib_debug(8, "snmp_msg_Encode:Encoding PDU Header at 0x%p (fake len %d) (%d bytes so far)\n",
bufp, *BufLenP, *BufLenP);
PDUHeaderPtr = bufp;
bufp = asn_build_header(bufp, BufLenP,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
(*BufLenP));
if (bufp == NULL)
return (NULL);
/* Encode this PDU. */
PDUDataStart = bufp;
bufp = snmp_pdu_encode(bufp, BufLenP, PDU);
if (bufp == NULL)
return (NULL); /* snmp_pdu_encode registered failure */
VARHeaderPtr = bufp;
bufp = asn_build_header(bufp, BufLenP,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
FakeArg);
if (bufp == NULL)
return (NULL);
VARDataStart = bufp;
/* And build the variables */
bufp = snmp_var_EncodeVarBind(bufp, BufLenP, PDU->variables, Version);
if (bufp == NULL)
return (NULL); /* snmp_var_EncodeVarBind registered failure */
/* Cool. Now insert the appropriate lengths.
*/
#if DEBUG_MSG_ENCODE
snmplib_debug(9, "Msg: Vars returned 0x%x. PDU Started at 0x%x\n",
bufp, PDUHeaderPtr);
snmplib_debug(9, "MSG: Entire PDU length is %d (0x%x - 0x%x)\n",
(int) (bufp - PDUDataStart), PDUHeaderPtr, bufp);
#endif
tmp = asn_build_header(PDUHeaderPtr, &FakeArg,
(u_char) PDU->command,
(int) (bufp - PDUDataStart));
/* Length of the PDU and Vars */
if (tmp == NULL)
return (NULL);
#if DEBUG_MSG_ENCODE
snmplib_debug(9, "MSG: Entire message length is %d (0x%x - 0x%x)\n",
(int) (bufp - MsgPtr), MsgPtr, bufp);
#endif
tmp = asn_build_header(Buffer,
&FakeArg,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
(bufp - MsgPtr)); /* Length of everything */
if (tmp == NULL)
return (NULL);
tmp = asn_build_header(VARHeaderPtr,
&FakeArg,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
(bufp - VARDataStart)); /* Length of everything */
if (tmp == NULL)
return (NULL);
*BufLenP = (bufp - Buffer);
return (u_char *) bufp;
}
int
smux_trap (oid *name, size_t namelen,
oid *iname, size_t inamelen,
struct trap_object *trapobj, size_t trapobjlen,
unsigned int tick, u_char sptrap)
{
unsigned int i;
u_char buf[BUFSIZ];
u_char *ptr;
size_t len, length;
struct in_addr addr;
unsigned long val;
u_char *h1, *h1e;
ptr = buf;
len = BUFSIZ;
length = len;
/* When SMUX connection is not established. */
if (smux_sock < 0)
return 0;
/* SMUX header. */
ptr = asn_build_header (ptr, &len, (u_char) SMUX_TRAP, 0);
/* Sub agent enterprise oid. */
ptr = asn_build_objid (ptr, &len,
(u_char)
(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
smux_oid, smux_oid_len);
/* IP address. */
addr.s_addr = 0;
ptr = asn_build_string (ptr, &len,
(u_char)
(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_IPADDRESS),
(u_char *)&addr, sizeof (addr));
/* Generic trap integer. */
val = SNMP_TRAP_ENTERPRISESPECIFIC;
ptr = asn_build_int (ptr, &len,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&val, sizeof (val));
/* Specific trap integer. */
val = sptrap;
ptr = asn_build_int (ptr, &len,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&val, sizeof (val));
/* Timeticks timestamp. */
val = 0;
ptr = asn_build_unsigned_int (ptr, &len,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_TIMETICKS),
&val, sizeof (val));
/* Variables. */
h1 = ptr;
ptr = asn_build_sequence (ptr, &len,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
0);
/* Iteration for each objects. */
h1e = ptr;
for (i = 0; i < trapobjlen; i++)
{
int ret;
oid oid[MAX_OID_LEN];
size_t oid_len;
void *val;
size_t val_len;
u_char val_type;
/* Make OID. */
if (trapobj[i].namelen > 0)
{
oid_copy (oid, name, namelen);
oid_copy (oid + namelen, trapobj[i].name, trapobj[i].namelen);
oid_copy (oid + namelen + trapobj[i].namelen, iname, inamelen);
oid_len = namelen + trapobj[i].namelen + inamelen;
}
else
{
oid_copy (oid, name, namelen);
oid_copy (oid + namelen, trapobj[i].name, trapobj[i].namelen * (-1));
oid_len = namelen + trapobj[i].namelen * (-1) ;
}
if (debug_smux)
{
smux_oid_dump ("Trap", name, namelen);
if (trapobj[i].namelen < 0)
smux_oid_dump ("Trap",
trapobj[i].name, (- 1) * (trapobj[i].namelen));
else
{
smux_oid_dump ("Trap", trapobj[i].name, (trapobj[i].namelen));
smux_oid_dump ("Trap", iname, inamelen);
}
smux_oid_dump ("Trap", oid, oid_len);
zlog_info ("BUFSIZ: %d // oid_len: %d", BUFSIZ, oid_len);
}
ret = smux_get (oid, &oid_len, 1, &val_type, &val, &val_len);
if (debug_smux)
zlog_debug ("smux_get result %d", ret);
if (ret == 0)
ptr = snmp_build_var_op (ptr, oid, &oid_len,
val_type, val_len, val, &len);
}
/* Now variable size is known, fill in size */
asn_build_sequence(h1, &length,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
ptr - h1e);
/* Fill in size of whole sequence */
len = BUFSIZ;
asn_build_header (buf, &len, (u_char) SMUX_TRAP, (ptr - buf) - 2);
return send (smux_sock, buf, (ptr - buf), 0);
}
u_char *
_docsis_snmp_build_var_op(u_char * data,
oid * var_name,
size_t * var_name_len,
u_char var_val_type,
size_t var_val_len,
u_char * var_val,
size_t * listlength)
{
size_t dummyLen, headerLen;
u_char *dataPtr;
dummyLen = *listlength;
dataPtr = data;
#if 0
data = asn_build_sequence(data, &dummyLen,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
0);
if (data == NULL) {
return NULL;
}
#endif
if (dummyLen < 2)
return NULL;
data += 2;
dummyLen -= 2;
headerLen = data - dataPtr;
*listlength -= headerLen;
DEBUGDUMPHEADER("send", "Name");
data = asn_build_objid(data, listlength,
(u_char) (ASN_UNIVERSAL | ASN_PRIMITIVE |
ASN_OBJECT_ID), var_name,
*var_name_len);
DEBUGINDENTLESS();
if (data == NULL) {
ERROR_MSG("Can't build OID for variable");
return NULL;
}
DEBUGDUMPHEADER("send", "Value");
switch (var_val_type) {
case ASN_INTEGER:
data = asn_build_int(data, listlength, var_val_type,
(long *) var_val, var_val_len);
break;
case ASN_GAUGE:
case ASN_COUNTER:
case ASN_TIMETICKS:
case ASN_UINTEGER:
data = asn_build_unsigned_int(data, listlength, var_val_type,
(u_long *) var_val, var_val_len);
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_COUNTER64:
case ASN_OPAQUE_U64:
#endif
case ASN_COUNTER64:
data = asn_build_unsigned_int64(data, listlength, var_val_type,
(struct counter64 *) var_val,
var_val_len);
break;
case ASN_OCTET_STR:
case ASN_IPADDRESS:
case ASN_OPAQUE:
case ASN_NSAP:
data = asn_build_string(data, listlength, var_val_type,
var_val, var_val_len);
break;
case ASN_OBJECT_ID:
data = asn_build_objid(data, listlength, var_val_type,
(oid *) var_val, var_val_len / sizeof(oid));
break;
case ASN_NULL:
data = asn_build_null(data, listlength, var_val_type);
break;
case ASN_BIT_STR:
data = asn_build_bitstring(data, listlength, var_val_type,
var_val, var_val_len);
break;
case SNMP_NOSUCHOBJECT:
case SNMP_NOSUCHINSTANCE:
case SNMP_ENDOFMIBVIEW:
data = asn_build_null(data, listlength, var_val_type);
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_FLOAT:
data = asn_build_float(data, listlength, var_val_type,
(float *) var_val, var_val_len);
break;
case ASN_OPAQUE_DOUBLE:
data = asn_build_double(data, listlength, var_val_type,
(double *) var_val, var_val_len);
break;
case ASN_OPAQUE_I64:
data = asn_build_signed_int64(data, listlength, var_val_type,
(struct counter64 *) var_val,
var_val_len);
break;
#endif /* OPAQUE_SPECIAL_TYPES */
default:
ERROR_MSG("wrong type");
return NULL;
}
DEBUGINDENTLESS();
if (data == NULL) {
ERROR_MSG("Can't build value");
return NULL;
}
dummyLen = (data - dataPtr) - headerLen;
_docsis_asn_build_sequence(dataPtr, &dummyLen,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
dummyLen);
return data;
}
/* Build a variable binding.
*
* RFC 1905: Protocol Operations for SNMPv2
*
* VarBind ::=
* SEQUENCE {
* name ObjectName
* CHOICE {
* value ObjectSyntax
* unSpecified NULL
* noSuchObject[0] NULL
* noSuchInstance[1] NULL
* endOfMibView[2] NULL
* }
* }
*/
u_char *snmp_var_EncodeVarBind(u_char *Buffer, int *BufLenP,
struct variable_list *VarList,
int Version)
{
struct variable_list *Vars;
u_char *bufp;
u_char *HeaderStart;
u_char *HeaderEnd;
int FakeArg = *BufLenP;
#ifdef DEBUG_VARS_ENCODE
int StartLen = *BufLenP;
int Counter = 1;
#endif
bufp = Buffer;
#ifdef DEBUG_VARS_ENCODE
printf("VARS: Encoding Variable list into buffer at 0x%x.\n", Buffer);
#endif
for (Vars=VarList; Vars; Vars=Vars->next_variable) {
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding Variable 0x%x.\n", Counter, Vars);
printf("VARS %d: Starting at 0x%x (%d bytes left)\n",
Counter, bufp, *BufLenP);
#endif
/* Build the header for this variable
*
* Use Maximum size.
*/
HeaderStart = bufp;
HeaderEnd = asn_build_header(HeaderStart, BufLenP,
(u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
FakeArg);
if (HeaderEnd == NULL)
return(NULL);
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding Object Identifier 0x%x (%d bytes) at 0x%x (%d bytes left)\n",
Counter, Vars,
Vars->name_length, HeaderEnd, *BufLenP);
print_oid(Vars->name, Vars->name_length),
#endif
/* Now, let's put the Object Identifier into the buffer */
bufp = asn_build_objid(HeaderEnd, BufLenP,
(u_char)(ASN_UNIVERSAL |
ASN_PRIMITIVE |
ASN_OBJECT_ID),
Vars->name, Vars->name_length);
if (bufp == NULL)
return(NULL);
/* Now put the data in */
switch(Vars->type) {
case ASN_INTEGER:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding Integer %d at 0x%x\n", Counter,
*(Vars->val.integer), bufp);
#endif
bufp = asn_build_int(bufp,
BufLenP, Vars->type,
(int *)Vars->val.integer, Vars->val_len);
break;
case SMI_COUNTER32:
case SMI_GAUGE32:
/* case SMI_UNSIGNED32: */
case SMI_TIMETICKS:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding Timeticks %d at 0x%x\n", Counter,
*(Vars->val.integer), bufp);
#endif
bufp = asn_build_unsigned_int(bufp, BufLenP,
Vars->type,
(u_int *)Vars->val.integer, Vars->val_len);
break;
case ASN_OCTET_STR:
case SMI_IPADDRESS:
case SMI_OPAQUE:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding String %s (%d bytes) at 0x%x\n", Counter,
(Vars->val.string), Vars->val_len, bufp);
#endif
bufp = asn_build_string(bufp, BufLenP, Vars->type,
Vars->val.string, Vars->val_len);
break;
case ASN_OBJECT_ID:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding Object Identifier (%d bytes) at 0x%x\n",
Counter,
Vars->val_len, bufp);
#endif
bufp = asn_build_objid(bufp, BufLenP, Vars->type,
(oid *)Vars->val.objid, Vars->val_len / sizeof(oid));
break;
case SMI_NOSUCHINSTANCE:
case SMI_NOSUCHOBJECT:
case SMI_ENDOFMIBVIEW:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding NULL at 0x%x\n", Counter, bufp);
#endif
if (Version == SNMP_VERSION_1) {
/* SNMP Version 1 does not support these error codes. */
bufp = asn_build_null(bufp, BufLenP, SMI_NOSUCHOBJECT);
} else {
bufp = asn_build_exception(bufp, BufLenP, Vars->type);
}
break;
case ASN_NULL:
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Encoding NULL at 0x%x\n", Counter, bufp);
#endif
bufp = asn_build_null(bufp, BufLenP, Vars->type);
break;
case SMI_COUNTER64:
#ifdef STDERR_OUTPUT
fprintf(stderr, WIDE("Unable to encode type SMI_COUNTER64!\n"));
#endif
/* Fall through */
default:
snmp_set_api_error(SNMPERR_UNSUPPORTED_TYPE);
return(NULL);
}
/* ASSERT: bufp should now point to the next valid byte. */
if (bufp == NULL)
return(NULL);
/* Rebuild the header with the appropriate length */
#ifdef DEBUG_VARS_ENCODE
printf("VARS %d: Resetting length to %d at 0x%x (%d bytes left)\n",
Counter,
(bufp - HeaderEnd), HeaderStart, *BufLenP);
#endif
HeaderEnd = asn_build_header(HeaderStart, &FakeArg,
(u_char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
(bufp - HeaderEnd));
/* Returns NULL */
if (HeaderEnd == NULL)
return(NULL);
#ifdef DEBUG_VARS_ENCODE
Counter++;
#endif
}
#ifdef DEBUG_VARS_ENCODE
printf("VARS: Variable list of %d vars takes up %d bytes.\n",
--Counter, StartLen - *BufLenP);
#endif
/* or the end of the entire thing */
return(bufp);
}
/*
* Takes a session and a pdu and serializes the ASN PDU into the area
* pointed to by packet. out_length is the size of the data area available.
* Returns the length of the completed packet in out_length. If any errors
* occur, -1 is returned. If all goes well, 0 is returned.
*/
int snmp_build_trap(
snmp_session *session,
snmp_pdu *pdu,
uint8 *packet,
int *out_length
)
{
uint8 buf[SNMP_MAX_TRAP_LEN];
uint8 *cp;
#ifdef WEBADMIN
uint8 *newpacket; // add -- by arius 5/18/2000
#endif WEBADMIN
variable_list *vp;
int totallength;
int length;
length = *out_length;
cp = packet;
for(vp = pdu->variables; vp; vp = vp->next){
cp = snmp_build_var_op(cp, vp->name, &vp->name_len, vp->type, vp->val_len, (uint8 *)vp->val.string, &length);
if (cp == NULL) return (FALSE);
}
totallength = cp - packet;
length = SNMP_MAX_TRAP_LEN;
cp = asn_build_header(buf, &length, (uint8)(ASN_SEQUENCE | ASN_CONSTRUCTOR), totallength);
if (cp == NULL) return (FALSE);
bcopy((char *)packet, (char *)cp, totallength);
totallength += cp - buf;
length = *out_length;
if (pdu->command != TRP_REQ_MSG){
// request id
cp = asn_build_int(packet, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(long *)&pdu->reqid, sizeof(pdu->reqid));
if (cp == NULL) return (FALSE);
// error status
cp = asn_build_int(cp, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(long *)&pdu->errstatus, sizeof(pdu->errstatus));
if(cp == NULL) return (FALSE);
// error index
cp = asn_build_int(cp, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(long *)&pdu->errindex, sizeof(pdu->errindex));
if(cp == NULL) return (FALSE);
} else { // this is a trap message
// enterprise
cp = asn_build_objid(packet, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
(oid *)SnmpVersionID, SNMP_VER_LEN);
if (cp == NULL) return (FALSE);
// agent-addr
cp = asn_build_string(cp, &length, (uint8)IPADDRESS,
(uint8 *)&pdu->agent_addr.sin_addr.s_addr, sizeof(pdu->agent_addr.sin_addr.s_addr));
if(cp == NULL) return (FALSE);
// generic trap
cp = asn_build_int(cp, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(long *)&pdu->generic_trap, sizeof(pdu->generic_trap));
if (cp == NULL) return (FALSE);
// specific trap
cp = asn_build_int(cp, &length,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(long *)&pdu->specific_trap, sizeof(pdu->specific_trap));
if (cp == NULL) return (FALSE);
// timestamp
cp = asn_build_int(cp, &length, (uint8)TIMETICKS,
(long *)&pdu->time_stamp, sizeof(pdu->time_stamp));
if (cp == NULL) return (FALSE);
}
if (length < totallength) return (FALSE);
bcopy((char *)buf, (char *)cp, totallength);
totallength += cp - packet;
length = SNMP_MAX_TRAP_LEN;
cp = asn_build_header(buf, &length, (uint8)pdu->command, totallength);
if (cp == NULL) return (FALSE);
if (length < totallength) return (FALSE);
bcopy((char *)packet, (char *)cp, totallength);
totallength += cp - buf;
length = *out_length;
// modified -- by arius 5/18/2000
#ifdef WEBADMIN
newpacket = packet;
cp = snmp_build_auth( newpacket, &length, session->community,
session->community_len,(long) SNMP_VERSION_1, totallength);
cp -= totallength; // save new pointer
#else
cp = snmp_build_auth( packet, &length, session->community,
session->community_len,(long) SNMP_VERSION_1, totallength);
#endif WEBADMIN
// end of here
if (cp == NULL) return (FALSE);
if ((*out_length - (cp - packet)) < totallength) return (FALSE);
bcopy((char *)buf, (char *)cp, totallength);
totallength += cp - packet;
*out_length = totallength;
// if( session->qoS & USEC_QOS_AUTH )
// md5Digest( packet, totallength, cp - (session->contextLen + 16),
// cp - (session->contextLen + 16) );
return (TRUE);
}
//*
//*---------------------------------------------------------------------------------
//* Function Name: snmp_build_auth
//* Description : Encodes the community name and version number in BER encoding
//* rules.
//* Return Value : pointer of message with community name and version number encoded
//* in it.
//*---------------------------------------------------------------------------------
//*
uint8 *snmp_build_auth(
uint8 *outdata,
int *outlength,
uint8 *community,
int community_len,
long version,
int messagelen
)
{
// build the the message wrapper (30 82 Length)
// 5 bytes = version header + version value + community header
// add -- By arius 5/17/2000
#ifdef WEBADMIN
uint8 *oldoutdata;
int newoutlength;
oldoutdata = outdata;
outdata = asn_build_sequence(outdata, outlength, (uint8)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
0);
#else
outdata = asn_build_sequence(outdata, outlength, (uint8)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
messagelen + community_len + 5);
#endif WEBADMIN
// end of here
if (outdata == NULL){
ERROR("buildheader");
return NULL;
}
// store the version field (02 length version)
outdata = asn_build_int(outdata, outlength,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&version, sizeof(version));
if(outdata == NULL){
ERROR("buildint");
return NULL;
}
outdata = asn_build_string(outdata, outlength,
(uint8)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STRING),
community, community_len);
if(outdata == NULL){
ERROR("buildstring");
return NULL;
}
// add -- By arius 5/17/2000
#ifdef WEBADMIN
if (messagelen)
{
newoutlength = *outlength + (community_len + 5 + 4); // (default 4) include 30 82 Length
outdata = asn_build_sequence(oldoutdata, &newoutlength , (uint8)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
messagelen + community_len + 5);
}
#endif WEBADMIN
// end of here
return outdata;
}
/* Build a variable binding.
*
* RFC 1905: Protocol Operations for SNMPv2
*
* VarBind ::=
* SEQUENCE {
* name ObjectName
* CHOICE {
* value ObjectSyntax
* unSpecified NULL
* noSuchObject[0] NULL
* noSuchInstance[1] NULL
* endOfMibView[2] NULL
* }
* }
*/
u_char *
snmp_var_EncodeVarBind(u_char * Buffer, int *BufLenP,
variable_list * VarList,
int Version)
{
struct variable_list *Vars;
u_char *bufp;
u_char *HeaderStart;
u_char *HeaderEnd;
int FakeArg = *BufLenP;
bufp = Buffer;
for (Vars = VarList; Vars; Vars = Vars->next_variable) {
/* Build the header for this variable
*
* Use Maximum size.
*/
HeaderStart = bufp;
HeaderEnd = asn_build_header(HeaderStart, BufLenP,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
FakeArg);
if (HeaderEnd == NULL)
return (NULL);
/* Now, let's put the Object Identifier into the buffer */
bufp = asn_build_objid(HeaderEnd, BufLenP,
(u_char) (ASN_UNIVERSAL |
ASN_PRIMITIVE |
ASN_OBJECT_ID),
Vars->name, Vars->name_length);
if (bufp == NULL)
return (NULL);
/* Now put the data in */
switch (Vars->type) {
case ASN_INTEGER:
bufp = asn_build_int(bufp,
BufLenP, Vars->type,
(int *) Vars->val.integer, Vars->val_len);
break;
case SMI_COUNTER32:
case SMI_GAUGE32:
/* case SMI_UNSIGNED32: */
case SMI_TIMETICKS:
bufp = asn_build_unsigned_int(bufp, BufLenP,
Vars->type,
(u_int *) Vars->val.integer, Vars->val_len);
break;
case ASN_OCTET_STR:
case SMI_IPADDRESS:
case SMI_OPAQUE:
bufp = asn_build_string(bufp, BufLenP, Vars->type,
Vars->val.string, Vars->val_len);
break;
case ASN_OBJECT_ID:
bufp = asn_build_objid(bufp, BufLenP, Vars->type,
(oid *) Vars->val.objid, Vars->val_len / sizeof(oid));
break;
case SMI_NOSUCHINSTANCE:
case SMI_NOSUCHOBJECT:
case SMI_ENDOFMIBVIEW:
if (Version == SNMP_VERSION_1) {
/* SNMP Version 1 does not support these error codes. */
bufp = asn_build_null(bufp, BufLenP, SMI_NOSUCHOBJECT);
} else {
bufp = asn_build_exception(bufp, BufLenP, Vars->type);
}
break;
case ASN_NULL:
bufp = asn_build_null(bufp, BufLenP, Vars->type);
break;
case SMI_COUNTER64:
snmplib_debug(2, "Unable to encode type SMI_COUNTER64!\n");
/* Fall through */
default:
snmp_set_api_error(SNMPERR_UNSUPPORTED_TYPE);
return (NULL);
}
/* ASSERT: bufp should now point to the next valid byte. */
if (bufp == NULL)
return (NULL);
/* Rebuild the header with the appropriate length */
HeaderEnd = asn_build_header(HeaderStart, &FakeArg,
(u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
(bufp - HeaderEnd));
/* Returns NULL */
if (HeaderEnd == NULL)
return (NULL);
}
/* or the end of the entire thing */
return (bufp);
}
u_char *snmp_pdu_encode(u_char *DestBuf, int *DestBufLen,
struct snmp_pdu *PDU)
{
u_char *bufp;
#ifdef DEBUG_PDU_ENCODE
printf("PDU: Encoding %d\n", PDU->command);
#endif
/* ASN.1 Header */
switch (PDU->command) {
/**********************************************************************/
case TRP_REQ_MSG:
/* SNMPv1 Trap */
/* enterprise */
bufp = asn_build_objid(DestBuf, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
(oid *)PDU->enterprise, PDU->enterprise_length);
if (bufp == NULL)
return(NULL);
/* agent-addr */
bufp = asn_build_string(bufp, DestBufLen,
(u_char)(SMI_IPADDRESS | ASN_PRIMITIVE),
(u_char *)&PDU->agent_addr.sin_addr.s_addr,
sizeof(PDU->agent_addr.sin_addr.s_addr));
if (bufp == NULL)
return(NULL);
/* generic trap */
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(int *)&PDU->trap_type, sizeof(PDU->trap_type));
if (bufp == NULL)
return(NULL);
/* specific trap */
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
(int *)&PDU->specific_type,
sizeof(PDU->specific_type));
if (bufp == NULL)
return(NULL);
/* timestamp */
bufp = asn_build_unsigned_int(bufp, DestBufLen,
(u_char)(SMI_TIMETICKS | ASN_PRIMITIVE),
&PDU->time, sizeof(PDU->time));
if (bufp == NULL)
return(NULL);
break;
/**********************************************************************/
case SNMP_PDU_GETBULK:
/* SNMPv2 Bulk Request */
/* request id */
bufp = asn_build_int(DestBuf, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->reqid, sizeof(PDU->reqid));
if (bufp == NULL)
return(NULL);
/* non-repeaters */
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->non_repeaters,
sizeof(PDU->non_repeaters));
if (bufp == NULL)
return(NULL);
/* max-repetitions */
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->max_repetitions,
sizeof(PDU->max_repetitions));
if (bufp == NULL)
return(NULL);
break;
/**********************************************************************/
default:
/* Normal PDU Encoding */
/* request id */
#ifdef DEBUG_PDU_ENCODE
printf("PDU: Request ID %d (0x%x)\n", PDU->reqid, DestBuf);
#endif
bufp = asn_build_int(DestBuf, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->reqid, sizeof(PDU->reqid));
if (bufp == NULL)
return(NULL);
/* error status */
#ifdef DEBUG_PDU_ENCODE
printf("PDU: Error Status %d (0x%x)\n", PDU->errstat, bufp);
#endif
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->errstat, sizeof(PDU->errstat));
if (bufp == NULL)
return(NULL);
/* error index */
#ifdef DEBUG_PDU_ENCODE
printf("PDU: Error index %d (0x%x)\n", PDU->errindex, bufp);
#endif
bufp = asn_build_int(bufp, DestBufLen,
(u_char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
&PDU->errindex, sizeof(PDU->errindex));
if (bufp == NULL)
return(NULL);
break;
} /* End of encoding */
return(bufp);
}
