asn1.cpp

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

    case SMI_TIMETICKS:
    case SMI_UINTEGER:
      vp->val.integer = (long *)malloc(sizeof(long));
      vp->val_len = sizeof(long);
      asn_parse_unsigned_int(var_val, &len, &vp->type, (unsigned long *)vp->val.integer, sizeof(*vp->val.integer));
      break;

    case SMI_COUNTER64:
      vp->val.counter64 = (struct counter64 *)malloc( sizeof(struct counter64) );
      vp->val_len = sizeof(struct counter64);
      asn_parse_unsigned_int64(var_val, &len, &vp->type,
			       (struct counter64 *)vp->val.counter64,
			       sizeof(*vp->val.counter64));
      break;
	
    case ASN_OCTET_STR:
    case SMI_IPADDRESS:
    case SMI_OPAQUE:
    case SMI_NSAP:
      vp->val.string = (unsigned char *)malloc((unsigned)vp->val_len);
      asn_parse_string(var_val, &len, &vp->type, vp->val.string, &vp->val_len);
      break;

    case ASN_OBJECT_ID:
      vp->val_len = ASN_MAX_NAME_LEN;
      asn_parse_objid(var_val, &len, &vp->type, objid, &vp->val_len);
      //vp->val_len *= sizeof(oid);
      vp->val.objid = (oid *)malloc((unsigned)vp->val_len * sizeof(oid));
      // fixed
      memcpy((char *)vp->val.objid,
	     (char *)objid,
	     vp->val_len * sizeof(oid));
      break;

    case SNMP_NOSUCHOBJECT:
    case SNMP_NOSUCHINSTANCE:
    case SNMP_ENDOFMIBVIEW:
    case ASN_NULL:
      break;

    default:
      ASNERROR("bad type returned ");
      return SNMP_CLASS_ASN1ERROR;
      break;
    }
  }
  return SNMP_CLASS_SUCCESS;
}


int snmp_parse_data_pdu(snmp_pdu *pdu, unsigned char *&data, int &length)
{
  oid	    objid[ASN_MAX_NAME_LEN];
  int	    four = 4;
  unsigned char  type;

  data = asn_parse_header(data, &length, &type);
  if (data == NULL) return SNMP_CLASS_ASN1ERROR;

  pdu->command = type;

  if (pdu->command != TRP_REQ_MSG)
  {
    // get the rid
    data = asn_parse_int(data, &length, &type,
			 (long *)&pdu->reqid, sizeof(pdu->reqid));
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    // get the error status
    data = asn_parse_int(data, &length, &type,
			 (long *)&pdu->errstat, sizeof(pdu->errstat));
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    // get the error index
    data = asn_parse_int(data, &length, &type,
			 (long *)&pdu->errindex, sizeof(pdu->errindex));
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;
  }
  else
  {  // is a trap

    // get the enterprise
    pdu->enterprise_length = ASN_MAX_NAME_LEN;
    data = asn_parse_objid(data, &length, &type,
			   objid, &pdu->enterprise_length);
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    pdu->enterprise = (oid *)malloc(pdu->enterprise_length * sizeof(oid));

    memcpy((char *)pdu->enterprise,(char *)objid,
	   pdu->enterprise_length * sizeof(oid));

    // get source address
    data = asn_parse_string(data, &length, &type,
			    (unsigned char *)&pdu->agent_addr.sin_addr.s_addr,
			    &four);
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    // get trap type
    long dummy = 0;
    data = asn_parse_int(data, &length, &type, &dummy, sizeof(dummy));
    pdu->trap_type = dummy;

    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    // trap type
    dummy = 0;
    data = asn_parse_int(data, &length, &type, &dummy, sizeof(dummy));
    pdu->specific_type = dummy;
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;

    // timestamp
    data = asn_parse_unsigned_int(data, &length, &type,
                                  &pdu->time, sizeof(pdu->time));
    if (data == NULL) return SNMP_CLASS_ASN1ERROR;
  }
  return SNMP_CLASS_SUCCESS;
}


// parse a pdu
int snmp_parse( struct snmp_pdu *pdu,
                unsigned char *data, int data_length,
		unsigned char *community_name,
		int &community_len,
		snmp_version &spp_version)
{
  long    version = -1;

  // authenticates message and returns length if valid
  data = snmp_auth_parse(data, &data_length,
			 community_name, &community_len,
			 &version);
  if (data == NULL)
    return SNMP_CLASS_ASN1ERROR;

  if(version != SNMP_VERSION_1 && version != SNMP_VERSION_2C ) {
    ASNERROR("Wrong version");
    return SNMP_CLASS_BADVERSION;
  }

  spp_version = (snmp_version) version;

  int res = snmp_parse_data_pdu(pdu, data, data_length);
  if (res != SNMP_CLASS_SUCCESS)
    return res;

  return snmp_parse_vb(pdu, data, data_length);
}


#ifdef _SNMPv3
// Parse the field HeaderData of a SNMPv3 message and return the values.
unsigned char *asn1_parse_header_data(unsigned char *buf, int *buf_len,
				      long *msg_id, long *msg_max_size,
				      unsigned char *msg_flags,
				      long *msg_security_model)
{
  unsigned char *buf_ptr = buf;
  int length = *buf_len;
  unsigned char type;

  buf = asn_parse_header( buf, &length, &type);
  if (!buf)
  {
    debugprintf(0, "Parse error in header HeaderData");
    return 0;
  }

  if (type != (ASN_SEQ_CON)){
    debugprintf(0, "wrong type in header of msgHeaderData");
    return 0;
  }

  buf = asn_parse_int(buf, &length, &type, msg_id, sizeof(*msg_id));
  if (!buf){
    debugprintf(0, "Parse error: msg_id");
    return 0;
  }

  buf = asn_parse_int(buf, &length,
		      &type, msg_max_size, sizeof(*msg_max_size));
  if (!buf){
    debugprintf(0, "Parse error: msg_max_size");
    return 0;
  }

  int dummy = 1;
  buf = asn_parse_string( buf, &length, &type, msg_flags, &dummy);

  if ((dummy !=1) || (!buf)) {
    debugprintf(0, "Parse error: msg_flags");
    return 0;
  }

  buf = asn_parse_int(buf, &length, &type,
		      msg_security_model, sizeof(*msg_security_model));
  if (!buf){
    debugprintf(0, "Parse error: msg_security_model");
    return 0;
  }

  if (length) {
    debugprintf(0, "Parse error: wrong length in header of HeaderData");
    return 0;
  }

  debugprintf(3, "Parsed HeaderData: globalDataLength(0x%x), msg_id(0x%lx), "
	     "msg_max_size(0x%lx), msg_flags(0x%x), msg_security_model(0x%lx)",
	      length, *msg_id, *msg_max_size, *msg_flags, *msg_security_model);

  *buf_len -= SAFE_INT_CAST(buf - buf_ptr);
  return buf;
}

// Encode the given values for the HeaderData into the buffer.
unsigned char *asn1_build_header_data(unsigned char *outBuf, int *maxLength,
				       long msgID,
				       long maxMessageSize,
				       unsigned char msgFlags,
				       long securityModel)

{
  unsigned char buf[MAXLENGTH_GLOBALDATA];
  unsigned char *bufPtr = (unsigned char*)&buf;
  unsigned char *outBufPtr = outBuf;
  int length = *maxLength;
  int totalLength;

#ifdef INVALID_MAXMSGSIZE
  debugprintf(-10, "\nWARNING: Using constant MaxMessageSize!\n");
  maxMessageSize = 65535;
#endif

  debugprintf(3, "Coding msgID(0x%lx), maxMessageSize(0x%lx), "
	      "msgFlags(0x%x), securityModel(0x%lx)",
              msgID, maxMessageSize, msgFlags, securityModel);

  bufPtr = asn_build_int(bufPtr, &length,
                         (unsigned char)(ASN_UNI_PRIV | ASN_INTEGER),
                         (long *)&msgID, sizeof(msgID));
  if (bufPtr == NULL){
    debugprintf(0, "asn_build_header_data: Error coding msgID");
    return NULL;
  }
  bufPtr = asn_build_int(bufPtr, &length,
                         (unsigned char)(ASN_UNI_PRIV | ASN_INTEGER),
                         (long *)&maxMessageSize, sizeof(maxMessageSize));
  if (bufPtr == NULL){
    debugprintf(0, "asn_build_header_data: Error coding maxMessageSize");
    return NULL;
  }

  bufPtr = asn_build_string(bufPtr, &length,
                            (unsigned char)(ASN_UNI_PRIV | ASN_OCTET_STR),
                            (unsigned char*)&msgFlags, 1);
  if (bufPtr == NULL){
    debugprintf(0, "asn_build_header_data: Error coding msgFlags");
    return NULL;
  }

  bufPtr = asn_build_int(bufPtr, &length,
                         (unsigned char)(ASN_UNI_PRIV | ASN_INTEGER),
                         (long *)&securityModel, sizeof(securityModel));
  if (bufPtr == NULL){
    debugprintf(0, "asn_build_header_data: Error coding securityModel");
    return NULL;
  }

  totalLength = SAFE_INT_CAST(bufPtr - (unsigned char*)&buf);

  debugprintf(3, "Coding sequence (headerdata), length = 0x%x", totalLength);
  outBufPtr = asn_build_sequence(outBufPtr, maxLength,
                                 (unsigned char)(ASN_SEQ_CON),
                                 totalLength);

  if (outBufPtr == NULL) {
    debugprintf(0, "asn_build_header_data: Error coding seq headerdata");
    return NULL;
  }

  if (*maxLength < totalLength) {
    debugprintf(0, "asn_build_header_data: Length error");
    return NULL;
  }

  memcpy(outBufPtr, (unsigned char*)&buf, totalLength);
  outBufPtr += totalLength;
  *maxLength -= totalLength;

  debugprintf(21, "bufHeaderData:");
  debughexprintf(21, outBuf, SAFE_INT_CAST(outBufPtr - outBuf));

  return outBufPtr;
}
#endif

// Parse the ScopedPDU and return the encoded values.
unsigned char *asn1_parse_scoped_pdu(
         unsigned char *scoped_pdu, int *scoped_pdu_len,
         unsigned char *context_engine_id, int *context_engine_id_len,
         unsigned char *context_name, int *context_name_len )
{
  unsigned char type;

  scoped_pdu = asn_parse_header( scoped_pdu, scoped_pdu_len, &type);
  if (!scoped_pdu) {
    debugprintf(0, "Parse error: Wrong header in scoped_pdu.");
    return 0;
  }

  if (type != (ASN_SEQ_CON)){
    debugprintf(0, "Parse error: Wrong header type in scoped_pdu.");
    return 0;
  }

  scoped_pdu = asn_parse_string( scoped_pdu, scoped_pdu_len, &type,
                                context_engine_id, context_engine_id_len);
  if (!scoped_pdu){
    debugprintf(0, "Parse error: context_engine_id");
    return 0;
  }

  scoped_pdu = asn_parse_string( scoped_pdu, scoped_pdu_len, &type,
                                context_name, context_name_len);
  if (!scoped_pdu){
    debugprintf(0, "mpParseScopedPDU: bad parse of context_name");
    return 0;
  }

  debugprintf(3, "Parsed scoped_pdu: context_engine_id length(0x%x), "
	      "context_name length(0x%x)",
	      *context_engine_id_len, *context_name_len);

  return scoped_pdu;
}

// Encode the given values for the scopedPDU into the buffer.
unsigned char *asn1_build_scoped_pdu(
                   unsigned char *outBuf, int *max_len,
                   unsigned char *contextEngineID, long contextEngineIDLength,
                   unsigned char *contextName, long contextNameLength,
                   unsigned char *data, long dataLength)
{
  Buffer<unsigned char> buffer(MAX_SNMP_PACKET);
  unsigned char *bufPtr = buffer.get_ptr();
  unsigned char *outBufPtr = outBuf;
  long  bufLength = 0;

  LOG_BEGIN(DEBUG_LOG | 10);
  LOG("ASN1: coding (context engine id) (context name)");
  LOG(OctetStr(contextEngineID, contextEngineIDLength).get_printable());
  LOG(OctetStr(contextName, contextNameLength).get_printable());
  LOG_END;

  bufPtr = asn_build_string(bufPtr, max_len,
                            (unsigned char)(ASN_UNI_PRIV | ASN_OCTET_STR),
                            contextEngineID, contextEngineIDLength);
  if (!bufPtr)
  {
    LOG_BEGIN(ERROR_LOG | 1);
    LOG("ASN1: Error encoding contextEngineID");
    LOG_END;

    return 0;
  }

  bufPtr = asn_build_string(bufPtr, max_len,
                            (unsigned char)(ASN_UNI_PRIV | ASN_OCTET_STR),
                            contextName, contextNameLength);
  if (!bufPtr)
  {
    LOG_BEGIN(ERROR_LOG | 1);
    LOG("ASN1: Error encoding contextName");
    LOG_END;

    return 0;
  }

  bufLength = SAFE_INT_CAST(bufPtr - buffer.get_ptr());

  memcpy((char *)bufPtr, (char *)data, dataLength);
  bufLength += dataLength;

  LOG_BEGIN(DEBUG_LOG | 10);
  LOG("ASN1: Encoding scoped PDU sequence (len)");
  LOG(bufLength);
  LOG_END;

  outBufPtr = asn_build_sequence(outBufPtr, max_len,
                                 (unsigned char)(ASN_SEQ_CON),
                                 bufLength);
  if (!outBufPtr)
  {
    LOG_BEGIN(ERROR_LOG | 1);
    LOG("ASN1: Error encoding scopedPDU sequence");
    LOG_END;

    return 0;
  }

  memcpy(outBufPtr, buffer.get_ptr(), bufLength);
  outBufPtr += bufLength;

#ifdef __DEBUG
  LOG_BEGIN(DEBUG_LOG | 15);
  LOG("ASN1: Result of build_scoped_pdu (len) (data)");
  LOG(outBufPtr - outBuf);
  LOG(OctetStr(outBuf, outBufPtr - outBuf).get_printable_hex());
  LOG_END;
#endif

  return outBufPtr;
}

#ifdef SNMP_PP_NAMESPACE
}; // end of namespace Snmp_pp
#endif