asn1.cpp

来自「JdonFramework need above jdk 1.4.0 This」· C++ 代码 · 共 2,107 行 · 第 1/5 页

  // This assumes that community will not be longer than 0x7f chars.
  data = asn_build_sequence(data, length,
			    (unsigned char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
			    messagelen + community_len + 5);
  if (data == NULL){ 
    ASNERROR("buildheader");
    return NULL;
  }
  data = asn_build_int(data, length,
		       (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
		       &version, sizeof(version));
  if (data == NULL){
    ASNERROR("buildint");
    return NULL;
  }

  data = asn_build_string(data, length,
			  (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OCTET_STR),
			  community, community_len);
  if (data == NULL){
    ASNERROR("buildstring");
    return NULL;
  }

  return data;
}


// build a variable binding
unsigned char * snmp_build_var_op(unsigned char *data,
				  oid * var_name,
				  int *var_name_len,
				  unsigned char var_val_type,
				  int var_val_len,
				  unsigned char *var_val,
				  int *listlength)
{
  int valueLen;
  Buffer<unsigned char> buffer(MAX_SNMP_PACKET);
  unsigned char *buffer_pos = buffer.get_ptr();
  int bufferLen = MAX_SNMP_PACKET;

  buffer_pos = asn_build_objid( buffer_pos,
			  &bufferLen,
			  (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
			  var_name,
			  *var_name_len);
  if (buffer_pos == NULL){
    ASNERROR("build_var_op: build_objid failed");
    return NULL;
  }

  // based on the type...
  switch(var_val_type){
  case ASN_INTEGER:
    buffer_pos = asn_build_int(buffer_pos, &bufferLen,
                               var_val_type,
                               (long *)var_val, var_val_len);
    break;

  case SMI_GAUGE:
  case SMI_COUNTER:
  case SMI_TIMETICKS:
  case SMI_UINTEGER:
    buffer_pos = asn_build_unsigned_int(buffer_pos, &bufferLen,
                                        var_val_type,
                                        (unsigned long *)var_val, var_val_len);
    break;

  case SMI_COUNTER64:
    buffer_pos = asn_build_unsigned_int64(buffer_pos, &bufferLen,
                                          var_val_type,
                                          (struct counter64 *)var_val,
                                          var_val_len);
    break;

  case ASN_OCTET_STR:
  case SMI_IPADDRESS:
  case SMI_OPAQUE:
  case SMI_NSAP:
    buffer_pos = asn_build_string(buffer_pos, &bufferLen, var_val_type,
                                  var_val, var_val_len);
    break;

  case ASN_OBJECT_ID:
    buffer_pos = asn_build_objid(buffer_pos, &bufferLen, var_val_type,
                                 (oid *)var_val, var_val_len / sizeof(oid));
    break;

  case ASN_NULL:
    buffer_pos = asn_build_null(buffer_pos, &bufferLen, var_val_type);
    break;

  case ASN_BIT_STR:
    buffer_pos = asn_build_bitstring(buffer_pos, &bufferLen, var_val_type,
                                     var_val, var_val_len);
    break;

  case SNMP_NOSUCHOBJECT:
  case SNMP_NOSUCHINSTANCE:
  case SNMP_ENDOFMIBVIEW:
    buffer_pos = asn_build_null(buffer_pos, &bufferLen, var_val_type);
    break;

  default:
    ASNERROR("build_var_op: wrong type");
    return NULL;
  }
  if (buffer_pos == NULL){
    ASNERROR("build_var_op: value build failed");
    return NULL;
  }

  valueLen = SAFE_INT_CAST(buffer_pos - buffer.get_ptr());

  data = asn_build_sequence(data, listlength,
                            (unsigned char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
                            valueLen);

  if( data == NULL || *listlength < valueLen )
  {
    ASNERROR( "build_var_op" );
    data = NULL;
  }
  else
  {
    memcpy(data, buffer.get_ptr(), valueLen );
    data += valueLen;
    (*listlength)-=valueLen;
  }
  return data;
}


unsigned char *build_vb(struct snmp_pdu *pdu,
			unsigned char *buf, int *buf_len)
{
  Buffer<unsigned char> tmp_buf(MAX_SNMP_PACKET);
  unsigned char *cp = tmp_buf.get_ptr();
  struct   variable_list *vp;
  int vb_length;
  int length = MAX_SNMP_PACKET;

  // build varbinds into packet buffer
  for(vp = pdu->variables; vp; vp = vp->next_variable)
  {
    cp = snmp_build_var_op( cp, vp->name, &vp->name_length,
			    vp->type, vp->val_len,
			    (unsigned char *)vp->val.string,
			    &length);
    if (cp == NULL) return 0;
  }
  vb_length = SAFE_INT_CAST(cp - tmp_buf.get_ptr());
  *buf_len -= vb_length;
  if (*buf_len <= 0) return 0;

  // encode the length of encoded varbinds into buf
  cp = asn_build_header( buf, buf_len,
			 (unsigned char)(ASN_SEQUENCE | ASN_CONSTRUCTOR),
			 vb_length);
  if (cp == NULL) return 0;

  // copy varbinds from packet behind header in buf
  memcpy(cp, tmp_buf.get_ptr(), vb_length);

  return (cp + vb_length);
}

unsigned char *build_data_pdu(struct snmp_pdu *pdu,
			      unsigned char *buf, int *buf_len,
			      unsigned char *vb_buf, int vb_buf_len)
{
  Buffer<unsigned char> tmp_buf(MAX_SNMP_PACKET);
  unsigned char *cp = tmp_buf.get_ptr();
  int totallength;
  int length = MAX_SNMP_PACKET;

  // build data of pdu into tmp_buf
  if (pdu->command != TRP_REQ_MSG)
  {
    // request id
    cp = asn_build_int( cp, &length,
			(unsigned char )(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
			(long *)&pdu->reqid, sizeof(pdu->reqid));
    if (cp == NULL) return 0;

    // error status
    cp = asn_build_int(cp, &length,
		       (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
		       (long *)&pdu->errstat, sizeof(pdu->errstat));
    if (cp == NULL) return 0;

    // error index
    cp = asn_build_int(cp, &length,
		       (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
		       (long *)&pdu->errindex, sizeof(pdu->errindex));
    if (cp == NULL) return 0;
  }
  else
  { // this is a trap message
    // enterprise
    cp = asn_build_objid( cp, &length,
			  (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID),
			  (oid *)pdu->enterprise, pdu->enterprise_length);
    if (cp == NULL) return 0;

    // agent-addr ; must be IPADDRESS changed by Frank Fock
    cp = asn_build_string(cp, &length,
			  (unsigned char)(SMI_IPADDRESS),
			  (unsigned char *)&pdu->agent_addr.sin_addr.s_addr,
			  sizeof(pdu->agent_addr.sin_addr.s_addr));
    if (cp == NULL) return 0;

    long dummy = pdu->trap_type;
    // generic trap
    cp = asn_build_int(cp, &length,
		       (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
		       &dummy, sizeof(dummy));
    if (cp == NULL) return 0;

    dummy = pdu->specific_type;
    // specific trap
    cp = asn_build_int( cp, &length,
			(unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_INTEGER),
			&dummy, sizeof(dummy));
    if (cp == NULL) return 0;

    // timestamp
    cp = asn_build_unsigned_int(cp, &length,
                                (unsigned char )(SMI_TIMETICKS),
                                &pdu->time, sizeof(pdu->time));
    if (cp == NULL) return 0;
  }

  if (length < vb_buf_len) return 0;

  // save relative position of varbinds
  int vb_rel_pos = SAFE_INT_CAST(cp - tmp_buf.get_ptr());
  totallength = SAFE_INT_CAST(cp - tmp_buf.get_ptr()) + vb_buf_len;

  // build header for datapdu into buf
  cp = asn_build_header(buf, buf_len,
			(unsigned char)pdu->command, totallength);
  if (cp == NULL) return 0;
  if (*buf_len < totallength) return 0;

  // copy data behind header
  memcpy(cp, tmp_buf.get_ptr(), totallength - vb_buf_len);
  memcpy((char *)cp + vb_rel_pos, (char *)vb_buf, vb_buf_len);
  *buf_len -= totallength;
  return (cp + totallength);
}

// serialize the pdu
int snmp_build(struct snmp_pdu	*pdu,
               unsigned char *packet,          int *out_length,
               const long version,
               const unsigned char* community, const int community_len)
{
  Buffer<unsigned char> buf(MAX_SNMP_PACKET);
  unsigned char  *cp;
  int	     length;
  int	 totallength;

  // encode vbs with header into packet
  length = *out_length;
  cp = build_vb(pdu, packet, &length);
  if (cp == 0) return -1;
  totallength = SAFE_INT_CAST(cp - packet);
  if (totallength >= *out_length) return -1;

  // encode datadpu into buf
  length = MAX_SNMP_PACKET;
  cp = build_data_pdu(pdu, buf.get_ptr(), &length,
		      packet, totallength);
  if (cp == 0) return -1;
  totallength = SAFE_INT_CAST(cp - buf.get_ptr());
  if (totallength >= *out_length) return -1;

  // build SNMP header
  length = *out_length;
  cp = snmp_auth_build( packet, &length, version,
			community, community_len, totallength );
  if (cp == NULL) return -1;
  if ((*out_length - (cp - packet)) < totallength) return -1;

  // copy data
  memcpy(cp, buf.get_ptr(), totallength);
  totallength += SAFE_INT_CAST(cp - packet);
  *out_length = totallength;

  return 0;
}

// parse the authentication header
unsigned char *snmp_auth_parse(unsigned char *data,
                               int *length,
                               unsigned char *community,
			       int *community_len,
                               long	*version)
{
  unsigned char type;

  // get the type
  data = asn_parse_header(data, length, &type);
  if (data == NULL){
    ASNERROR("bad header");
    return NULL;
  }

  if (type != (ASN_SEQUENCE | ASN_CONSTRUCTOR)){
    ASNERROR("wrong auth header type");
    return NULL;
  }

  // get the version
  data = asn_parse_int(data, length, &type, version, sizeof(*version));
  if (data == NULL){
    ASNERROR("bad parse of version");
    return NULL;
  }

  // get the community name
  data = asn_parse_string(data, length, &type, community, community_len);
  if (data == NULL){
    ASNERROR("bad parse of community");
    return NULL;
  }

  return (unsigned char *)data;
}

unsigned char *
snmp_parse_var_op( unsigned char *data,  // IN - pointer to the start of object
		   oid	    *var_name,	         // OUT - object id of variable
		   int	    *var_name_len,       // IN/OUT - length of variable name
		   unsigned char  *var_val_type, // OUT - type of variable (int or octet string) (one byte)
		   int	    *var_val_len,        // OUT - length of variable
		   unsigned char  **var_val,	 // OUT - pointer to ASN1 encoded value of variable
		   int	    *listlength)         // IN/OUT - number of valid bytes left in var_op_list
{
  unsigned char var_op_type;
  int	var_op_len = *listlength;
  unsigned char *var_op_start = data;

  data = asn_parse_header(data, &var_op_len, &var_op_type);
  if (data == NULL){
    ASNERROR("Error snmp_parse_var_op: 1");
    return NULL;
  }
  if (var_op_type != (unsigned  char)(ASN_SEQUENCE | ASN_CONSTRUCTOR))
    return NULL;
  data = asn_parse_objid(data, &var_op_len, &var_op_type, var_name, var_name_len);
  if (data == NULL){
    ASNERROR("Error snmp_parse_var_op: 2");
    return NULL;
  }
  if (var_op_type != (unsigned char)(ASN_UNIVERSAL | ASN_PRIMITIVE | ASN_OBJECT_ID))
    return NULL;
  *var_val = data;	/* save pointer to this object */
  /* find out what type of object this is */
  data = asn_parse_header(data, &var_op_len, var_val_type);
  if (data == NULL){
    ASNERROR("Error snmp_parse_var_op: 3");
    return NULL;
  }
  if (((unsigned long)var_op_len + (data - var_op_start)) > (unsigned long)(*listlength)) {
    ASNERROR("Error snmp_parse_var_op: 4");
    return NULL;
  }
  *var_val_len = (int)var_op_len;
  data += var_op_len;
  *listlength -= (int)(data - var_op_start);
  return data;
}


int snmp_parse_vb(struct snmp_pdu *pdu, unsigned char *&data, int &data_len)
{
  unsigned char  *var_val;
  int len;
  struct variable_list *vp;
  oid	    objid[ASN_MAX_NAME_LEN], *op;
  unsigned char type;

  // get the vb list from received data
  data = asn_parse_header(data, &data_len, &type);
  if (data == NULL)
    return SNMP_CLASS_ASN1ERROR;
  if (type != (unsigned char)(ASN_SEQUENCE | ASN_CONSTRUCTOR))
    return SNMP_CLASS_ASN1ERROR;
  pdu->variables = NULL;
  while(data_len > 0){
    if (pdu->variables == NULL){
      pdu->variables = vp = (struct variable_list *)malloc(sizeof(struct variable_list));
    } else {
      vp->next_variable = (struct variable_list *)malloc(sizeof(struct variable_list));
      vp = vp->next_variable;
    }
    vp->next_variable = NULL;
    vp->val.string = NULL;
    vp->name = NULL;
    vp->name_length = ASN_MAX_NAME_LEN;
    data = snmp_parse_var_op( data, objid, &vp->name_length, &vp->type,
			      &vp->val_len, &var_val, &data_len);
    if (data == NULL)
      return SNMP_CLASS_ASN1ERROR;
    op = (oid *)malloc((unsigned)vp->name_length * sizeof(oid));
    // fixed
    memcpy((char *)op, (char *)objid, vp->name_length * sizeof(oid));
    vp->name = op;

    len = MAX_SNMP_PACKET;
    switch((short)vp->type){
    case ASN_INTEGER:
      vp->val.integer = (long *)malloc(sizeof(long));
      vp->val_len = sizeof(long);
      asn_parse_int(var_val, &len, &vp->type, (long *)vp->val.integer, sizeof(*vp->val.integer));
      break;

    case SMI_COUNTER:
    case SMI_GAUGE: