001package org.apache.commons.ssl.org.bouncycastle.asn1.dvcs; 002 003import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Boolean; 004import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1EncodableVector; 005import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Object; 006import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Primitive; 007import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1Sequence; 008import org.apache.commons.ssl.org.bouncycastle.asn1.ASN1TaggedObject; 009import org.apache.commons.ssl.org.bouncycastle.asn1.DERSequence; 010import org.apache.commons.ssl.org.bouncycastle.asn1.DERTaggedObject; 011import org.apache.commons.ssl.org.bouncycastle.asn1.x509.PolicyInformation; 012 013/** 014 * <pre> 015 * PathProcInput ::= SEQUENCE { 016 * acceptablePolicySet SEQUENCE SIZE (1..MAX) OF 017 * PolicyInformation, 018 * inhibitPolicyMapping BOOLEAN DEFAULT FALSE, 019 * explicitPolicyReqd [0] BOOLEAN DEFAULT FALSE , 020 * inhibitAnyPolicy [1] BOOLEAN DEFAULT FALSE 021 * } 022 * </pre> 023 */ 024public class PathProcInput 025 extends ASN1Object 026{ 027 028 private PolicyInformation[] acceptablePolicySet; 029 private boolean inhibitPolicyMapping = false; 030 private boolean explicitPolicyReqd = false; 031 private boolean inhibitAnyPolicy = false; 032 033 public PathProcInput(PolicyInformation[] acceptablePolicySet) 034 { 035 this.acceptablePolicySet = acceptablePolicySet; 036 } 037 038 public PathProcInput(PolicyInformation[] acceptablePolicySet, boolean inhibitPolicyMapping, boolean explicitPolicyReqd, boolean inhibitAnyPolicy) 039 { 040 this.acceptablePolicySet = acceptablePolicySet; 041 this.inhibitPolicyMapping = inhibitPolicyMapping; 042 this.explicitPolicyReqd = explicitPolicyReqd; 043 this.inhibitAnyPolicy = inhibitAnyPolicy; 044 } 045 046 private static PolicyInformation[] fromSequence(ASN1Sequence seq) 047 { 048 PolicyInformation[] tmp = new PolicyInformation[seq.size()]; 049 050 for (int i = 0; i != tmp.length; i++) 051 { 052 tmp[i] = PolicyInformation.getInstance(seq.getObjectAt(i)); 053 } 054 055 return tmp; 056 } 057 058 public static PathProcInput getInstance(Object obj) 059 { 060 if (obj instanceof PathProcInput) 061 { 062 return (PathProcInput)obj; 063 } 064 else if (obj != null) 065 { 066 ASN1Sequence seq = ASN1Sequence.getInstance(obj); 067 ASN1Sequence policies = ASN1Sequence.getInstance(seq.getObjectAt(0)); 068 PathProcInput result = new PathProcInput(fromSequence(policies)); 069 070 for (int i = 1; i < seq.size(); i++) 071 { 072 Object o = seq.getObjectAt(i); 073 074 if (o instanceof ASN1Boolean) 075 { 076 ASN1Boolean x = ASN1Boolean.getInstance(o); 077 result.setInhibitPolicyMapping(x.isTrue()); 078 } 079 else if (o instanceof ASN1TaggedObject) 080 { 081 ASN1TaggedObject t = ASN1TaggedObject.getInstance(o); 082 ASN1Boolean x; 083 switch (t.getTagNo()) 084 { 085 case 0: 086 x = ASN1Boolean.getInstance(t, false); 087 result.setExplicitPolicyReqd(x.isTrue()); 088 break; 089 case 1: 090 x = ASN1Boolean.getInstance(t, false); 091 result.setInhibitAnyPolicy(x.isTrue()); 092 } 093 } 094 } 095 return result; 096 } 097 098 return null; 099 } 100 101 public static PathProcInput getInstance( 102 ASN1TaggedObject obj, 103 boolean explicit) 104 { 105 return getInstance(ASN1Sequence.getInstance(obj, explicit)); 106 } 107 108 public ASN1Primitive toASN1Primitive() 109 { 110 ASN1EncodableVector v = new ASN1EncodableVector(); 111 ASN1EncodableVector pV = new ASN1EncodableVector(); 112 113 for (int i = 0; i != acceptablePolicySet.length; i++) 114 { 115 pV.add(acceptablePolicySet[i]); 116 } 117 118 v.add(new DERSequence(pV)); 119 120 if (inhibitPolicyMapping) 121 { 122 v.add(new ASN1Boolean(inhibitPolicyMapping)); 123 } 124 if (explicitPolicyReqd) 125 { 126 v.add(new DERTaggedObject(false, 0, new ASN1Boolean(explicitPolicyReqd))); 127 } 128 if (inhibitAnyPolicy) 129 { 130 v.add(new DERTaggedObject(false, 1, new ASN1Boolean(inhibitAnyPolicy))); 131 } 132 133 return new DERSequence(v); 134 } 135 136 public String toString() 137 { 138 return "PathProcInput: {\n" + 139 "acceptablePolicySet: " + acceptablePolicySet + "\n" + 140 "inhibitPolicyMapping: " + inhibitPolicyMapping + "\n" + 141 "explicitPolicyReqd: " + explicitPolicyReqd + "\n" + 142 "inhibitAnyPolicy: " + inhibitAnyPolicy + "\n" + 143 "}\n"; 144 } 145 146 public PolicyInformation[] getAcceptablePolicySet() 147 { 148 return acceptablePolicySet; 149 } 150 151 public boolean isInhibitPolicyMapping() 152 { 153 return inhibitPolicyMapping; 154 } 155 156 private void setInhibitPolicyMapping(boolean inhibitPolicyMapping) 157 { 158 this.inhibitPolicyMapping = inhibitPolicyMapping; 159 } 160 161 public boolean isExplicitPolicyReqd() 162 { 163 return explicitPolicyReqd; 164 } 165 166 private void setExplicitPolicyReqd(boolean explicitPolicyReqd) 167 { 168 this.explicitPolicyReqd = explicitPolicyReqd; 169 } 170 171 public boolean isInhibitAnyPolicy() 172 { 173 return inhibitAnyPolicy; 174 } 175 176 private void setInhibitAnyPolicy(boolean inhibitAnyPolicy) 177 { 178 this.inhibitAnyPolicy = inhibitAnyPolicy; 179 } 180}