[apple/security.git] / SecurityASN1 / c++ / pkcs7.cpp

//   NOTE: this is a machine generated file--editing not recommended
//
// pkcs7.cpp - class member functions for ASN.1 module PKCS7
//
//   This file was generated by snacc on Mon Apr 22 22:34:19 2002
//   UBC snacc written by Mike Sample
//   A couple of enhancements made by IBM European Networking Center


#include "asn-incl.h"
#include "sm_vdatypes.h"
#include "sm_x501ud.h"
#include "sm_x411ub.h"
#include "sm_x411mtsas.h"
#include "sm_x501if.h"
#include "sm_x520sa.h"
#include "sm_x509cmn.h"
#include "sm_x509af.h"
#include "sm_x509ce.h"
#include "pkcs1oids.h"
#include "pkcs9oids.h"
#include "sm_cms.h"
#include "sm_ess.h"
#include "pkcs7.h"
#include "pkcs8.h"
#include "appleoids.h"
#include "pkcs10.h"

//------------------------------------------------------------------------------
// value defs


//------------------------------------------------------------------------------
// class member definitions:

EncryptedContentInfo1::EncryptedContentInfo1()
{
#if TCL
  contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
#else
  contentEncryptionAlgorithm = NULL; // incomplete initialization of mandatory element!
#endif // TCL
  encryptedContent = NULL;
}

EncryptedContentInfo1::EncryptedContentInfo1 (const EncryptedContentInfo1 &)
{
  Asn1Error << "use of incompletely defined EncryptedContentInfo1::EncryptedContentInfo1 (const EncryptedContentInfo1 &)" << endl;
  abort();
}

EncryptedContentInfo1::~EncryptedContentInfo1()
{
  delete contentEncryptionAlgorithm;
  delete encryptedContent;
}

AsnType *EncryptedContentInfo1::Clone() const
{
  return new EncryptedContentInfo1;
}

AsnType *EncryptedContentInfo1::Copy() const
{
  return new EncryptedContentInfo1 (*this);
}

#if SNACC_DEEP_COPY
EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &that)
#else // SNACC_DEEP_COPY
EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    contentType = that.contentType;
    if (that.contentEncryptionAlgorithm)
    {
      if (!contentEncryptionAlgorithm)
        contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
      *contentEncryptionAlgorithm = *that.contentEncryptionAlgorithm;
    }
    else
    {
      delete contentEncryptionAlgorithm;
      contentEncryptionAlgorithm = NULL;
    }
    if (that.encryptedContent)
    {
      if (!encryptedContent)
        encryptedContent = new EncryptedContent1;
      *encryptedContent = *that.encryptedContent;
    }
    else
    {
      delete encryptedContent;
      encryptedContent = NULL;
    }
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
EncryptedContentInfo1::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

  if (NOT_NULL (encryptedContent))
  {
    l = encryptedContent->BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, CNTX, PRIM, 0);
    totalLen += l;
  }

      BEncEocIfNec (b);
    l = contentEncryptionAlgorithm->BEncContent (b);
    l += BEncConsLen (b, l);

    l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
    totalLen += l;

    l = contentType.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OID_TAG_CODE);
    totalLen += l;

  return totalLen;
} // EncryptedContentInfo1::BEncContent


void EncryptedContentInfo1::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OID_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    contentType.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    SnaccExcep::throwMe(-100);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
    contentEncryptionAlgorithm->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    if (seqBytesDecoded == elmtLen0)
    {
      bytesDecoded += seqBytesDecoded;
      return;
    }
    else
    {
      tag1 = BDecTag (b, seqBytesDecoded, env);

      if ((elmtLen0 == INDEFINITE_LEN) && (tag1 == EOC_TAG_ID))
      {
        BDEC_2ND_EOC_OCTET (b, seqBytesDecoded, env)
        bytesDecoded += seqBytesDecoded;
        return;
      }
    }
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    SnaccExcep::throwMe(-101);
  }

  if ((tag1 == MAKE_TAG_ID (CNTX, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (CNTX, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    encryptedContent = new EncryptedContent1;
    encryptedContent->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    SnaccExcep::throwMe(-102);
  }
  else
    return;
} // EncryptedContentInfo1::BDecContent

AsnLen EncryptedContentInfo1::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void EncryptedContentInfo1::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "EncryptedContentInfo1::BDec: ERROR - wrong tag" << endl;
    SnaccExcep::throwMe(-103);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

void EncryptedContentInfo1::Print (ostream &os) const
{
#ifndef NDEBUG
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "contentType ";
    os << contentType;
    os << "," << endl;
  }

  if (NOT_NULL (contentEncryptionAlgorithm))
  {
    Indent (os, indentG);
    os << "contentEncryptionAlgorithm ";
    os << *contentEncryptionAlgorithm;
  }
  else
  {
    Indent (os, indentG);
    os << "contentEncryptionAlgorithm ";
    os << "-- void --";
    os << "," << endl;
  }

  if (NOT_NULL (encryptedContent))
  {
    os << ","<< endl;
    Indent (os, indentG);
    os << "encryptedContent ";
    os << *encryptedContent;
  }
  else
  {
    Indent (os, indentG);
    os << "encryptedContent ";
    os << "-- void --";
    os << endl;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
#endif /* NDEBUG */
} // EncryptedContentInfo1::Print


EncryptedData1::EncryptedData1()
{
#if TCL
  encryptedContentInfo = new EncryptedContentInfo1;
#else
  encryptedContentInfo = NULL; // incomplete initialization of mandatory element!
#endif // TCL
}

EncryptedData1::EncryptedData1 (const EncryptedData1 &)
{
  Asn1Error << "use of incompletely defined EncryptedData1::EncryptedData1 (const EncryptedData1 &)" << endl;
  abort();
}

EncryptedData1::~EncryptedData1()
{
  delete encryptedContentInfo;
}

AsnType *EncryptedData1::Clone() const
{
  return new EncryptedData1;
}

AsnType *EncryptedData1::Copy() const
{
  return new EncryptedData1 (*this);
}

#if SNACC_DEEP_COPY
EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &that)
#else // SNACC_DEEP_COPY
EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    version = that.version;
    if (that.encryptedContentInfo)
    {
      if (!encryptedContentInfo)
        encryptedContentInfo = new EncryptedContentInfo1;
      *encryptedContentInfo = *that.encryptedContentInfo;
    }
    else
    {
      delete encryptedContentInfo;
      encryptedContentInfo = NULL;
    }
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
EncryptedData1::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

      BEncEocIfNec (b);
    l = encryptedContentInfo->BEncContent (b);
    l += BEncConsLen (b, l);

    l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
    totalLen += l;

    l = version.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // EncryptedData1::BEncContent


void EncryptedData1::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    version.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    SnaccExcep::throwMe(-104);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    encryptedContentInfo = new EncryptedContentInfo1;
    encryptedContentInfo->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    SnaccExcep::throwMe(-105);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    SnaccExcep::throwMe(-106);
  }
  else
    return;
} // EncryptedData1::BDecContent

AsnLen EncryptedData1::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void EncryptedData1::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "EncryptedData1::BDec: ERROR - wrong tag" << endl;
    SnaccExcep::throwMe(-107);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

void EncryptedData1::Print (ostream &os) const
{
#ifndef NDEBUG
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "version ";
    os << version;
    os << "," << endl;
  }

  if (NOT_NULL (encryptedContentInfo))
  {
    Indent (os, indentG);
    os << "encryptedContentInfo ";
    os << *encryptedContentInfo;
  }
  else
  {
    Indent (os, indentG);
    os << "encryptedContentInfo ";
    os << "-- void --";
    os << endl;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
#endif /* NDEBUG */
} // EncryptedData1::Print
Commit	Line	Data
bac41a7b A	1	// NOTE: this is a machine generated file--editing not recommended
	2	//
	3	// pkcs7.cpp - class member functions for ASN.1 module PKCS7
	4	//
29654253	5	// This file was generated by snacc on Mon Apr 22 22:34:19 2002
bac41a7b A	6	// UBC snacc written by Mike Sample
	7	// A couple of enhancements made by IBM European Networking Center
	8
	9
	10	#include "asn-incl.h"
	11	#include "sm_vdatypes.h"
	12	#include "sm_x501ud.h"
	13	#include "sm_x411ub.h"
	14	#include "sm_x411mtsas.h"
	15	#include "sm_x501if.h"
	16	#include "sm_x520sa.h"
	17	#include "sm_x509cmn.h"
	18	#include "sm_x509af.h"
	19	#include "sm_x509ce.h"
	20	#include "pkcs1oids.h"
	21	#include "pkcs9oids.h"
	22	#include "sm_cms.h"
	23	#include "sm_ess.h"
	24	#include "pkcs7.h"
	25	#include "pkcs8.h"
	26	#include "appleoids.h"
29654253	27	#include "pkcs10.h"
bac41a7b A	28
	29	//------------------------------------------------------------------------------
	30	// value defs
	31
	32
	33	//------------------------------------------------------------------------------
	34	// class member definitions:
	35
	36	EncryptedContentInfo1::EncryptedContentInfo1()
	37	{
	38	#if TCL
	39	contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
	40	#else
	41	contentEncryptionAlgorithm = NULL; // incomplete initialization of mandatory element!
	42	#endif // TCL
	43	encryptedContent = NULL;
	44	}
	45
	46	EncryptedContentInfo1::EncryptedContentInfo1 (const EncryptedContentInfo1 &)
	47	{
	48	Asn1Error << "use of incompletely defined EncryptedContentInfo1::EncryptedContentInfo1 (const EncryptedContentInfo1 &)" << endl;
	49	abort();
	50	}
	51
	52	EncryptedContentInfo1::~EncryptedContentInfo1()
	53	{
	54	delete contentEncryptionAlgorithm;
	55	delete encryptedContent;
	56	}
	57
	58	AsnType *EncryptedContentInfo1::Clone() const
	59	{
	60	return new EncryptedContentInfo1;
	61	}
	62
	63	AsnType *EncryptedContentInfo1::Copy() const
	64	{
	65	return new EncryptedContentInfo1 (*this);
	66	}
	67
	68	#if SNACC_DEEP_COPY
	69	EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &that)
	70	#else // SNACC_DEEP_COPY
	71	EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &)
	72	#endif // SNACC_DEEP_COPY
	73	{
	74	#if SNACC_DEEP_COPY
	75	if (this != &that)
	76	{
	77	contentType = that.contentType;
	78	if (that.contentEncryptionAlgorithm)
	79	{
	80	if (!contentEncryptionAlgorithm)
	81	contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
	82	contentEncryptionAlgorithm = that.contentEncryptionAlgorithm;
	83	}
	84	else
	85	{
	86	delete contentEncryptionAlgorithm;
	87	contentEncryptionAlgorithm = NULL;
	88	}
	89	if (that.encryptedContent)
	90	{
	91	if (!encryptedContent)
92	encryptedContent = new EncryptedContent1;
93	encryptedContent = that.encryptedContent;
94	}
95	else
96	{
97	delete encryptedContent;
98	encryptedContent = NULL;
99	}
100	}
101
102	return *this;
103	#else // SNACC_DEEP_COPY
104	Asn1Error << "use of incompletely defined EncryptedContentInfo1 &EncryptedContentInfo1::operator = (const EncryptedContentInfo1 &)" << endl;
105	abort();
106	// if your compiler complains here, check the -novolat option
107	#endif // SNACC_DEEP_COPY
108	}
109
110	AsnLen
111	EncryptedContentInfo1::BEncContent (BUF_TYPE b)
112	{
113	AsnLen totalLen = 0;
114	AsnLen l;
115
116	if (NOT_NULL (encryptedContent))
117	{
118	l = encryptedContent->BEncContent (b);
119	l += BEncDefLen (b, l);
120
121	l += BEncTag1 (b, CNTX, PRIM, 0);
122	totalLen += l;
123	}
124
125	BEncEocIfNec (b);
126	l = contentEncryptionAlgorithm->BEncContent (b);
127	l += BEncConsLen (b, l);
128
129	l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
130	totalLen += l;
131
132	l = contentType.BEncContent (b);
133	l += BEncDefLen (b, l);
134
135	l += BEncTag1 (b, UNIV, PRIM, OID_TAG_CODE);
136	totalLen += l;
137
138	return totalLen;
139	} // EncryptedContentInfo1::BEncContent
140
141
142	void EncryptedContentInfo1::BDecContent (BUF_TYPE b, AsnTag /tag0/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
143	{
144	AsnTag tag1;
145	AsnLen seqBytesDecoded = 0;
146	AsnLen elmtLen1;
147	tag1 = BDecTag (b, seqBytesDecoded, env);
148
149	if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OID_TAG_CODE)))
150	{
151	elmtLen1 = BDecLen (b, seqBytesDecoded, env);
152	contentType.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
153	tag1 = BDecTag (b, seqBytesDecoded, env);
154	}
155	else
156	{
157	Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
29654253	158	SnaccExcep::throwMe(-100);
bac41a7b A	159	}
	160
	161	if ((tag1 == MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
	162	{
	163	elmtLen1 = BDecLen (b, seqBytesDecoded, env);
	164	contentEncryptionAlgorithm = new ContentEncryptionAlgorithmIdentifier1;
	165	contentEncryptionAlgorithm->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
	166	if (seqBytesDecoded == elmtLen0)
	167	{
	168	bytesDecoded += seqBytesDecoded;
	169	return;
	170	}
	171	else
	172	{
	173	tag1 = BDecTag (b, seqBytesDecoded, env);
	174
	175	if ((elmtLen0 == INDEFINITE_LEN) && (tag1 == EOC_TAG_ID))
	176	{
	177	BDEC_2ND_EOC_OCTET (b, seqBytesDecoded, env)
	178	bytesDecoded += seqBytesDecoded;
	179	return;
	180	}
	181	}
	182	}
	183	else
	184	{
	185	Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
29654253	186	SnaccExcep::throwMe(-101);
bac41a7b A	187	}
	188
	189	if ((tag1 == MAKE_TAG_ID (CNTX, PRIM, 0))
	190	\|\| (tag1 == MAKE_TAG_ID (CNTX, CONS, 0)))
	191	{
	192	elmtLen1 = BDecLen (b, seqBytesDecoded, env);
	193	encryptedContent = new EncryptedContent1;
	194	encryptedContent->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
	195	}
	196
	197	bytesDecoded += seqBytesDecoded;
	198	if (elmtLen0 == INDEFINITE_LEN)
	199	{
	200	BDecEoc (b, bytesDecoded, env);
	201	return;
	202	}
	203	else if (seqBytesDecoded != elmtLen0)
	204	{
	205	Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
29654253	206	SnaccExcep::throwMe(-102);
bac41a7b A	207	}
	208	else
	209	return;
	210	} // EncryptedContentInfo1::BDecContent
	211
	212	AsnLen EncryptedContentInfo1::BEnc (BUF_TYPE b)
	213	{
	214	AsnLen l;
	215	l = BEncContent (b);
	216	l += BEncConsLen (b, l);
	217	l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
	218	return l;
	219	}
	220
	221	void EncryptedContentInfo1::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
	222	{
	223	AsnTag tag;
	224	AsnLen elmtLen1;
	225
	226	if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
	227	{
	228	Asn1Error << "EncryptedContentInfo1::BDec: ERROR - wrong tag" << endl;
29654253	229	SnaccExcep::throwMe(-103);
bac41a7b A	230	}
	231	elmtLen1 = BDecLen (b, bytesDecoded, env);
	232	BDecContent (b, tag, elmtLen1, bytesDecoded, env);
	233	}
	234
bac41a7b A	235	void EncryptedContentInfo1::Print (ostream &os) const
	236	{
	237	#ifndef NDEBUG
	238	os << "{ -- SEQUENCE --" << endl;
	239	indentG += stdIndentG;
	240
	241	{
	242	Indent (os, indentG);
	243	os << "contentType ";
	244	os << contentType;
	245	os << "," << endl;
	246	}
	247
	248	if (NOT_NULL (contentEncryptionAlgorithm))
	249	{
	250	Indent (os, indentG);
	251	os << "contentEncryptionAlgorithm ";
	252	os << *contentEncryptionAlgorithm;
	253	}
	254	else
	255	{
	256	Indent (os, indentG);
	257	os << "contentEncryptionAlgorithm ";
	258	os << "-- void --";
	259	os << "," << endl;
	260	}
	261
	262	if (NOT_NULL (encryptedContent))
	263	{
	264	os << ","<< endl;
	265	Indent (os, indentG);
	266	os << "encryptedContent ";
	267	os << *encryptedContent;
	268	}
	269	else
	270	{
	271	Indent (os, indentG);
	272	os << "encryptedContent ";
	273	os << "-- void --";
	274	os << endl;
	275	}
	276
	277	os << endl;
	278	indentG -= stdIndentG;
	279	Indent (os, indentG);
	280	os << "}";
	281	#endif /* NDEBUG */
	282	} // EncryptedContentInfo1::Print
	283
	284
	285	EncryptedData1::EncryptedData1()
	286	{
	287	#if TCL
	288	encryptedContentInfo = new EncryptedContentInfo1;
	289	#else
	290	encryptedContentInfo = NULL; // incomplete initialization of mandatory element!
	291	#endif // TCL
	292	}
	293
	294	EncryptedData1::EncryptedData1 (const EncryptedData1 &)
	295	{
	296	Asn1Error << "use of incompletely defined EncryptedData1::EncryptedData1 (const EncryptedData1 &)" << endl;
	297	abort();
	298	}
299
300	EncryptedData1::~EncryptedData1()
301	{
302	delete encryptedContentInfo;
303	}
304
305	AsnType *EncryptedData1::Clone() const
306	{
307	return new EncryptedData1;
308	}
309
310	AsnType *EncryptedData1::Copy() const
311	{
312	return new EncryptedData1 (*this);
313	}
314
315	#if SNACC_DEEP_COPY
316	EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &that)
317	#else // SNACC_DEEP_COPY
318	EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &)
319	#endif // SNACC_DEEP_COPY
320	{
321	#if SNACC_DEEP_COPY
322	if (this != &that)
323	{
324	version = that.version;
325	if (that.encryptedContentInfo)
326	{
327	if (!encryptedContentInfo)
328	encryptedContentInfo = new EncryptedContentInfo1;
329	encryptedContentInfo = that.encryptedContentInfo;
330	}
331	else
332	{
333	delete encryptedContentInfo;
334	encryptedContentInfo = NULL;
335	}
336	}
337
338	return *this;
339	#else // SNACC_DEEP_COPY
340	Asn1Error << "use of incompletely defined EncryptedData1 &EncryptedData1::operator = (const EncryptedData1 &)" << endl;
341	abort();
342	// if your compiler complains here, check the -novolat option
343	#endif // SNACC_DEEP_COPY
344	}
345
346	AsnLen
347	EncryptedData1::BEncContent (BUF_TYPE b)
348	{
349	AsnLen totalLen = 0;
350	AsnLen l;
351
352	BEncEocIfNec (b);
353	l = encryptedContentInfo->BEncContent (b);
354	l += BEncConsLen (b, l);
355
356	l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
357	totalLen += l;
358
359	l = version.BEncContent (b);
360	BEncDefLenTo127 (b, l);
361	l++;
362
363	l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
364	totalLen += l;
365
366	return totalLen;
367	} // EncryptedData1::BEncContent
368
369
370	void EncryptedData1::BDecContent (BUF_TYPE b, AsnTag /tag0/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
371	{
372	AsnTag tag1;
373	AsnLen seqBytesDecoded = 0;
374	AsnLen elmtLen1;
375	tag1 = BDecTag (b, seqBytesDecoded, env);
376
377	if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
378	{
379	elmtLen1 = BDecLen (b, seqBytesDecoded, env);
380	version.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
381	tag1 = BDecTag (b, seqBytesDecoded, env);
382	}
383	else
384	{
385	Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
29654253	386	SnaccExcep::throwMe(-104);
bac41a7b A	387	}
	388
	389	if ((tag1 == MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
	390	{
	391	elmtLen1 = BDecLen (b, seqBytesDecoded, env);
	392	encryptedContentInfo = new EncryptedContentInfo1;
	393	encryptedContentInfo->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
	394	}
	395	else
	396	{
	397	Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
29654253	398	SnaccExcep::throwMe(-105);
bac41a7b A	399	}
	400
	401	bytesDecoded += seqBytesDecoded;
	402	if (elmtLen0 == INDEFINITE_LEN)
	403	{
	404	BDecEoc (b, bytesDecoded, env);
	405	return;
	406	}
	407	else if (seqBytesDecoded != elmtLen0)
	408	{
	409	Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
29654253	410	SnaccExcep::throwMe(-106);
bac41a7b A	411	}
	412	else
	413	return;
	414	} // EncryptedData1::BDecContent
	415
	416	AsnLen EncryptedData1::BEnc (BUF_TYPE b)
	417	{
	418	AsnLen l;
	419	l = BEncContent (b);
	420	l += BEncConsLen (b, l);
	421	l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
	422	return l;
	423	}
	424
	425	void EncryptedData1::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
	426	{
	427	AsnTag tag;
	428	AsnLen elmtLen1;
	429
	430	if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
	431	{
	432	Asn1Error << "EncryptedData1::BDec: ERROR - wrong tag" << endl;
29654253	433	SnaccExcep::throwMe(-107);
bac41a7b A	434	}
	435	elmtLen1 = BDecLen (b, bytesDecoded, env);
	436	BDecContent (b, tag, elmtLen1, bytesDecoded, env);
	437	}
	438
bac41a7b A	439	void EncryptedData1::Print (ostream &os) const
	440	{
	441	#ifndef NDEBUG
	442	os << "{ -- SEQUENCE --" << endl;
	443	indentG += stdIndentG;
	444
	445	{
	446	Indent (os, indentG);
	447	os << "version ";
	448	os << version;
	449	os << "," << endl;
	450	}
	451
	452	if (NOT_NULL (encryptedContentInfo))
	453	{
	454	Indent (os, indentG);
	455	os << "encryptedContentInfo ";
	456	os << *encryptedContentInfo;
	457	}
	458	else
	459	{
	460	Indent (os, indentG);
	461	os << "encryptedContentInfo ";
	462	os << "-- void --";
	463	os << endl;
	464	}
	465
	466	os << endl;
	467	indentG -= stdIndentG;
	468	Indent (os, indentG);
	469	os << "}";
	470	#endif /* NDEBUG */
	471	} // EncryptedData1::Print
	472
	473