// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.mime.smime;

import java.util.Comparator;
import java.util.TreeMap;
import java.util.Collections;
import org.bouncycastle.cms.CMSAlgorithm;
import java.util.HashMap;
import java.io.IOException;
import java.io.FilterOutputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import org.bouncycastle.util.Strings;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

class SMimeUtils
{
    private static final Map RFC5751_MICALGS;
    private static final Map RFC3851_MICALGS;
    private static final Map STANDARD_MICALGS;
    private static final Map forMic;
    private static final byte[] nl;
    
    static String lessQuotes(final String s) {
        if (s == null || s.length() <= 1) {
            return s;
        }
        if (s.charAt(0) == '\"' && s.charAt(s.length() - 1) == '\"') {
            return s.substring(1, s.length() - 1);
        }
        return s;
    }
    
    static String getParameter(final String prefix, final List<String> list) {
        for (final String s : list) {
            if (s.startsWith(prefix)) {
                return s;
            }
        }
        return null;
    }
    
    static ASN1ObjectIdentifier getDigestOID(final String str) {
        final ASN1ObjectIdentifier asn1ObjectIdentifier = SMimeUtils.forMic.get(Strings.toLowerCase(str));
        if (asn1ObjectIdentifier == null) {
            throw new IllegalArgumentException("unknown micalg passed: " + str);
        }
        return asn1ObjectIdentifier;
    }
    
    static InputStream autoBuffer(final InputStream in) {
        if (in instanceof FileInputStream) {
            return new BufferedInputStream(in);
        }
        return in;
    }
    
    static OutputStream autoBuffer(final OutputStream out) {
        if (out instanceof FileOutputStream) {
            return new BufferedOutputStream(out);
        }
        return out;
    }
    
    static OutputStream createUnclosable(final OutputStream outputStream) {
        return new FilterOutputStream(outputStream) {
            @Override
            public void write(final byte[] b, final int off, final int len) throws IOException {
                if (b == null) {
                    throw new NullPointerException();
                }
                if ((off | len | b.length - (len + off) | off + len) < 0) {
                    throw new IndexOutOfBoundsException();
                }
                this.out.write(b, off, len);
            }
            
            @Override
            public void close() throws IOException {
            }
        };
    }
    
    static {
        (nl = new byte[2])[0] = 13;
        SMimeUtils.nl[1] = 10;
        final HashMap m = new HashMap();
        m.put(CMSAlgorithm.MD5, "md5");
        m.put(CMSAlgorithm.SHA1, "sha-1");
        m.put(CMSAlgorithm.SHA224, "sha-224");
        m.put(CMSAlgorithm.SHA256, "sha-256");
        m.put(CMSAlgorithm.SHA384, "sha-384");
        m.put(CMSAlgorithm.SHA512, "sha-512");
        m.put(CMSAlgorithm.GOST3411, "gostr3411-94");
        m.put(CMSAlgorithm.GOST3411_2012_256, "gostr3411-2012-256");
        m.put(CMSAlgorithm.GOST3411_2012_512, "gostr3411-2012-512");
        RFC5751_MICALGS = Collections.unmodifiableMap((Map<?, ?>)m);
        final HashMap i = new HashMap();
        i.put(CMSAlgorithm.MD5, "md5");
        i.put(CMSAlgorithm.SHA1, "sha1");
        i.put(CMSAlgorithm.SHA224, "sha224");
        i.put(CMSAlgorithm.SHA256, "sha256");
        i.put(CMSAlgorithm.SHA384, "sha384");
        i.put(CMSAlgorithm.SHA512, "sha512");
        i.put(CMSAlgorithm.GOST3411, "gostr3411-94");
        i.put(CMSAlgorithm.GOST3411_2012_256, "gostr3411-2012-256");
        i.put(CMSAlgorithm.GOST3411_2012_512, "gostr3411-2012-512");
        RFC3851_MICALGS = Collections.unmodifiableMap((Map<?, ?>)i);
        STANDARD_MICALGS = SMimeUtils.RFC5751_MICALGS;
        final TreeMap j = new TreeMap((Comparator<? super K>)String.CASE_INSENSITIVE_ORDER);
        for (final Object next : SMimeUtils.STANDARD_MICALGS.keySet()) {
            j.put(SMimeUtils.STANDARD_MICALGS.get(next).toString(), next);
        }
        for (final Object next2 : SMimeUtils.RFC3851_MICALGS.keySet()) {
            j.put(SMimeUtils.RFC3851_MICALGS.get(next2).toString(), next2);
        }
        forMic = Collections.unmodifiableMap((Map<?, ?>)j);
    }
}