Exemple #1
0
  private static void addBackTraceElement(
      Ruby runtime,
      RubyArray backtrace,
      RubyStackTraceElement frame,
      RubyStackTraceElement previousFrame) {
    if (frame != previousFrame
        && // happens with native exceptions, should not filter those out
        frame.getLineNumber() == previousFrame.getLineNumber()
        && frame.getMethodName() != null
        && frame.getMethodName().equals(previousFrame.getMethodName())
        && frame.getFileName() != null
        && frame.getFileName().equals(previousFrame.getFileName())) {
      return;
    }

    RubyString traceLine;
    String fileName = frame.getFileName();
    if (fileName == null) fileName = "";
    if (previousFrame.getMethodName() == UNKNOWN_NAME) {
      traceLine = RubyString.newString(runtime, fileName + ':' + (frame.getLineNumber()));
    } else {
      traceLine =
          RubyString.newString(
              runtime,
              fileName
                  + ':'
                  + (frame.getLineNumber())
                  + ":in `"
                  + previousFrame.getMethodName()
                  + '\'');
    }

    backtrace.append(traceLine);
  }
Exemple #2
0
  private static void addBackTraceElement(
      Ruby runtime, RubyArray backtrace, Frame frame, Frame previousFrame) {
    if (frame != previousFrame
        && // happens with native exceptions, should not filter those out
        frame.getLine() == previousFrame.getLine()
        && frame.getName() != null
        && frame.getName().equals(previousFrame.getName())
        && frame.getFile().equals(previousFrame.getFile())) {
      return;
    }

    RubyString traceLine;
    if (previousFrame.getName() != null) {
      traceLine =
          RubyString.newString(
              runtime,
              frame.getFile()
                  + ':'
                  + (frame.getLine() + 1)
                  + ":in `"
                  + previousFrame.getName()
                  + '\'');
    } else if (runtime.is1_9()) {
      // TODO: This probably isn't the best hack, but it works until we can have different
      // root frame setup for 1.9 easily.
      traceLine =
          RubyString.newString(
              runtime, frame.getFile() + ':' + (frame.getLine() + 1) + ":in `<main>'");
    } else {
      traceLine = RubyString.newString(runtime, frame.getFile() + ':' + (frame.getLine() + 1));
    }

    backtrace.append(traceLine);
  }
 /**
  * Take the boolean value and convert it to its bytes.
  *
  * @param bool The Ruby boolean value.
  * @return The byte array.
  * @since 2.0.0
  */
 private static RubyString toBsonBoolean(final IRubyObject bool) {
   final Ruby runtime = bool.getRuntime();
   if (bool == runtime.getTrue()) {
     return RubyString.newString(runtime, TRUE_BYTES);
   } else {
     return RubyString.newString(runtime, FALSE_BYTES);
   }
 }
  public void testUnicodeChars() throws Exception {
    File file = new File("unicodeáéíóú");
    if (file.exists()) {
      if (!file.delete()) {
        fail("Unable to delete file: " + file);
      }
    }
    try {
      if (!file.mkdirs()) {
        fail("Unable to create directory: " + file);
      }
      Ruby runtime;
      RubyInstanceConfig.nativeEnabled = false;
      runtime = Ruby.newInstance();

      JRubyFile rubyFile = RubyFile.file(RubyString.newString(runtime, file.getAbsolutePath()));
      assertTrue(rubyFile.exists());
      assertTrue(file.exists());
      assertTrue(file.isDirectory());
      try {
        assertTrue(runtime.getPosix().stat(rubyFile.getAbsolutePath()).isDirectory());
      } catch (Exception e) {
        throw new RuntimeException("Expecting posix layer to work properly", e);
      }
    } finally {
      if (file.exists()) {
        file.delete();
      }
    }
  }
Exemple #5
0
  @JRubyMethod(name = "sign")
  public IRubyObject sign(IRubyObject digest, IRubyObject data) {
    if (!this.callMethod(getRuntime().getCurrentContext(), "private?").isTrue()) {
      throw getRuntime().newArgumentError("Private key is needed.");
    }
    String digAlg = ((Digest) digest).getShortAlgorithm();
    try {
      Signature signature = SecurityHelper.getSignature(digAlg + "WITH" + getAlgorithm());
      signature.initSign(getPrivateKey());
      byte[] inp = data.convertToString().getBytes();
      signature.update(inp);
      byte[] sigge = signature.sign();
      return RubyString.newString(getRuntime(), sigge);
    } catch (GeneralSecurityException gse) {
      throw newPKeyError(getRuntime(), gse.getMessage());
    }
    /*
    GetPKey(self, pkey);
    EVP_SignInit(&ctx, GetDigestPtr(digest));
    StringValue(data);
    EVP_SignUpdate(&ctx, RSTRING(data)->ptr, RSTRING(data)->len);
    str = rb_str_new(0, EVP_PKEY_size(pkey)+16);
    if (!EVP_SignFinal(&ctx, RSTRING(str)->ptr, &buf_len, pkey))
    ossl_raise(ePKeyError, NULL);
    assert(buf_len <= RSTRING(str)->len);
    RSTRING(str)->len = buf_len;
    RSTRING(str)->ptr[buf_len] = 0;

    return str;
         */
  }
Exemple #6
0
  protected boolean tryLoadingLibraryOrScript(Ruby runtime, SearchState state) {
    // attempt to load the found library
    RubyString loadNameRubyString = RubyString.newString(runtime, state.loadName);
    try {
      synchronized (loadedFeaturesInternal) {
        if (loadedFeaturesInternal.contains(loadNameRubyString)) {
          return false;
        } else {
          addLoadedFeature(loadNameRubyString);
        }
      }

      // otherwise load the library we've found
      state.library.load(runtime, false);
      return true;
    } catch (MainExitException mee) {
      // allow MainExitException to propagate out for exec and friends
      throw mee;
    } catch (Throwable e) {
      if (isJarfileLibrary(state, state.searchFile)) {
        return true;
      }

      removeLoadedFeature(loadNameRubyString);
      reraiseRaiseExceptions(e);

      if (runtime.getDebug().isTrue()) e.printStackTrace(runtime.getErr());

      RaiseException re = newLoadErrorFromThrowable(runtime, state.searchFile, e);
      re.initCause(e);
      throw re;
    }
  }
Exemple #7
0
 @JRubyMethod
 public IRubyObject to_der() {
   try {
     return RubyString.newString(getRuntime(), crl_v.getEncoded());
   } catch (IOException ioe) {
     throw newX509CRLError(getRuntime(), ioe.getMessage());
   }
 }
  // Make string based on internal data encoding (which ironically is its
  // external encoding.  This seems messy and we should consider a more
  // uniform method for makeing strings (we have a slightly different variant
  // of this in RubyIO.
  private RubyString makeString(Ruby runtime, ByteList buf) {
    if (runtime.is1_9()) buf.setEncoding(data.internal.getEncoding());

    RubyString str = RubyString.newString(runtime, buf);
    str.setTaint(true);

    return str;
  }
Exemple #9
0
  // Make string based on internal data encoding (which ironically is its
  // external encoding.  This seems messy and we should consider a more
  // uniform method for makeing strings (we have a slightly different variant
  // of this in RubyIO.
  private RubyString makeString(Ruby runtime, ByteList buf, boolean setEncoding) {
    if (runtime.is1_9() && setEncoding) buf.setEncoding(ptr.string.getEncoding());

    RubyString str = RubyString.newString(runtime, buf);
    str.setTaint(true);

    return str;
  }
Exemple #10
0
 public void trySearch(SearchState state) throws AlreadyLoaded {
   for (String suffix : state.suffixType.getSuffixes()) {
     String searchName = state.searchFile + suffix;
     RubyString searchNameString = RubyString.newString(runtime, searchName);
     if (featureAlreadyLoaded(searchNameString)) {
       throw new AlreadyLoaded(searchNameString);
     }
   }
 }
 @Override
 @JRubyMethod
 public RubyString inspect() {
   StringBuilder str = new StringBuilder();
   str.append("#<");
   str.append(getDeclaringClass().nameOnInspection());
   inspectParameterTypes(str, this);
   str.append('>');
   return RubyString.newString(getRuntime(), str);
 }
  @JRubyMethod
  public IRubyObject recv(ThreadContext context, IRubyObject _length) {
    Ruby runtime = context.runtime;

    ByteList bytes = doReceive(context, RubyNumeric.fix2int(_length));

    if (bytes == null) return context.nil;

    return RubyString.newString(runtime, bytes);
  }
Exemple #13
0
 @Override
 public Object retrieve(
     ThreadContext context,
     IRubyObject self,
     StaticScope currScope,
     DynamicScope currDynScope,
     Object[] temp) {
   return context.runtime.freezeAndDedupString(
       RubyString.newString(context.runtime, bytelist, coderange));
 }
Exemple #14
0
 @JRubyMethod
 public IRubyObject to_der() {
   try {
     byte[] bytes = org.jruby.ext.openssl.impl.PKey.toDerDSAKey(pubKey, privKey);
     return RubyString.newString(getRuntime(), bytes);
   } catch (NoClassDefFoundError ncdfe) {
     throw newDSAError(getRuntime(), OpenSSLReal.bcExceptionMessage(ncdfe));
   } catch (IOException ioe) {
     throw newDSAError(getRuntime(), ioe.getMessage());
   }
 }
Exemple #15
0
 public void testStrConvEncThatGrows() throws Exception {
   String javaStr = "--- こんにちは!";
   RubyString rubyStr = RubyString.newString(runtime, javaStr);
   rubyStr =
       EncodingUtils.strConvEnc(
           runtime.getCurrentContext(), rubyStr, rubyStr.getEncoding(), SJISEncoding.INSTANCE);
   assertEquals(rubyStr.getEncoding(), SJISEncoding.INSTANCE);
   rubyStr =
       EncodingUtils.strConvEnc(
           runtime.getCurrentContext(), rubyStr, SJISEncoding.INSTANCE, UTF8Encoding.INSTANCE);
   assertEquals(rubyStr.getEncoding(), UTF8Encoding.INSTANCE);
 }
Exemple #16
0
  @Override
  @JRubyMethod(
      name = {"to_s", "inspect"},
      optional = 1)
  public IRubyObject to_s(ThreadContext context, IRubyObject[] args) {
    String s =
        size != Long.MAX_VALUE
            ? String.format(
                "#<%s address=0x%x size=%s>", getMetaClass().getName(), getAddress(), size)
            : String.format("#<%s address=0x%x>", getMetaClass().getName(), getAddress());

    return RubyString.newString(context.runtime, s);
  }
Exemple #17
0
 private IRubyObject userUnmarshal(MarshalState state) throws IOException {
   String className = unmarshalObject(false).asJavaString();
   ByteList marshaled = unmarshalString();
   RubyClass classInstance = findClass(className);
   RubyString data = RubyString.newString(getRuntime(), marshaled);
   if (state.isIvarWaiting()) {
     defaultVariablesUnmarshal(data);
     state.setIvarWaiting(false);
   }
   IRubyObject unmarshaled = classInstance.smartLoadOldUser(data);
   registerLinkTarget(unmarshaled);
   return unmarshaled;
 }
  @JRubyMethod
  public IRubyObject recv_nonblock(ThreadContext context, IRubyObject _length) {
    Ruby runtime = context.runtime;

    ByteList bytes = doReceiveNonblock(context, RubyNumeric.fix2int(_length));

    if (bytes == null) {
      if (runtime.is1_9()) {
        throw runtime.newErrnoEAGAINReadableError("recvfrom(2)");
      } else {
        throw runtime.newErrnoEAGAINError("recvfrom(2)");
      }
    }

    return RubyString.newString(runtime, bytes);
  }
Exemple #19
0
  public static IRubyObject createRawBacktrace(
      Ruby runtime, StackTraceElement[] stackTrace, boolean filter) {
    RubyArray traceArray = RubyArray.newArray(runtime);
    for (int i = 0; i < stackTrace.length; i++) {
      StackTraceElement element = stackTrace[i];

      if (filter) {
        if (element.getClassName().startsWith("org.jruby") || element.getLineNumber() < 0) {
          continue;
        }
      }
      RubyString str = RubyString.newString(runtime, createRubyBacktraceString(element));
      traceArray.append(str);
    }

    return traceArray;
  }
Exemple #20
0
  public static IRubyObject createRubyCompiledBacktrace(
      Ruby runtime, StackTraceElement[] stackTrace) {
    RubyArray traceArray = RubyArray.newArray(runtime);
    for (int i = 17; i < stackTrace.length; i++) {
      StackTraceElement element = stackTrace[i];
      int index = element.getMethodName().indexOf("$RUBY$");
      if (index < 0) continue;
      String unmangledMethod = element.getMethodName().substring(index + 6);
      RubyString str =
          RubyString.newString(
              runtime,
              element.getFileName()
                  + ":"
                  + element.getLineNumber()
                  + ":in `"
                  + unmangledMethod
                  + "'");
      traceArray.append(str);
    }

    return traceArray;
  }
Exemple #21
0
  public static IRubyObject generateMRIBacktrace(Ruby runtime, RubyStackTraceElement[] trace) {
    if (trace == null) {
      return runtime.getNil();
    }

    RubyArray traceArray = RubyArray.newArray(runtime);

    for (int i = 0; i < trace.length; i++) {
      RubyStackTraceElement element = trace[i];

      RubyString str =
          RubyString.newString(
              runtime,
              element.getFileName()
                  + ":"
                  + element.getLineNumber()
                  + ":in `"
                  + element.getMethodName()
                  + "'");
      traceArray.append(str);
    }

    return traceArray;
  }
Exemple #22
0
 @JRubyMethod(rest = true)
 public IRubyObject recv(ThreadContext context, IRubyObject[] args) {
   OpenFile openFile = getOpenFileChecked();
   try {
     context.getThread().beforeBlockingCall();
     return RubyString.newString(
         context.getRuntime(), openFile.getMainStream().read(RubyNumeric.fix2int(args[0])));
   } catch (BadDescriptorException e) {
     throw context.getRuntime().newErrnoEBADFError();
   } catch (EOFException e) {
     // recv returns nil on EOF
     return context.getRuntime().getNil();
   } catch (IOException e) {
     // All errors to sysread should be SystemCallErrors, but on a closed stream
     // Ruby returns an IOError.  Java throws same exception for all errors so
     // we resort to this hack...
     if ("Socket not open".equals(e.getMessage())) {
       throw context.getRuntime().newIOError(e.getMessage());
     }
     throw context.getRuntime().newSystemCallError(e.getMessage());
   } finally {
     context.getThread().afterBlockingCall();
   }
 }
Exemple #23
0
 @JRubyMethod(name = "ruby")
 public IRubyObject ruby(final ThreadContext ctx) {
   RubyString string = RubyString.newString(ctx.runtime, value.getBytes(), 0, value.getLength());
   string.setEncoding(UTF8Encoding.INSTANCE);
   return string;
 }
Exemple #24
0
 @JRubyMethod(name = "inspect")
 public IRubyObject inspect(ThreadContext context) {
   return RubyString.newString(context.getRuntime(), String.format("#<Buffer size=%d>", size));
 }
Exemple #25
0
  @JRubyMethod
  public IRubyObject parse(ThreadContext context, IRubyObject target) {
    Ruby runtime = context.runtime;

    // FIXME? only supports Unicode, since we have to produces strings...
    StreamReader reader;
    if (target.respondsTo("read")) {
      reader = new StreamReader(new InputStreamReader(new IOInputStream(target)));
    } else {
      reader = new StreamReader(new StringReader(target.convertToString().asJavaString()));
    }
    Parser parser = new ParserImpl(reader);
    IRubyObject handler = getInstanceVariable("@handler");
    Event event;

    while (true) {
      try {
        event = parser.getEvent();

        // FIXME: Event should expose a getID, so it can be switched
        if (event.is(ID.StreamStart)) {
          invoke(context, handler, "start_stream", runtime.newFixnum(YAML_ANY_ENCODING));
        } else if (event.is(ID.DocumentStart)) {
          DocumentStartEvent dse = (DocumentStartEvent) event;

          Integer[] versionInts = dse.getVersion();
          IRubyObject version =
              versionInts == null
                  ? runtime.getNil()
                  : RubyArray.newArray(
                      runtime,
                      runtime.newFixnum(versionInts[0]),
                      runtime.newFixnum(versionInts[1]));

          Map<String, String> tagsMap = dse.getTags();
          RubyArray tags = RubyArray.newArray(runtime);
          if (tags.size() > 0) {
            for (Map.Entry<String, String> tag : tagsMap.entrySet()) {
              tags.append(
                  RubyArray.newArray(
                      runtime,
                      RubyString.newString(runtime, tag.getKey()),
                      RubyString.newString(runtime, tag.getValue())));
            }
          }

          invoke(
              context,
              handler,
              "start_document",
              version,
              tags,
              runtime.newBoolean(dse.getExplicit()));
        } else if (event.is(ID.DocumentEnd)) {
          DocumentEndEvent dee = (DocumentEndEvent) event;
          invoke(context, handler, "end_document", runtime.newBoolean(dee.getExplicit()));
        } else if (event.is(ID.Alias)) {
          AliasEvent ae = (AliasEvent) event;
          IRubyObject alias = runtime.getNil();
          if (ae.getAnchor() != null) {
            alias = RubyString.newString(runtime, ae.getAnchor());
          }

          invoke(context, handler, "alias", alias);
        } else if (event.is(ID.Scalar)) {
          ScalarEvent se = (ScalarEvent) event;
          IRubyObject anchor =
              se.getAnchor() == null
                  ? runtime.getNil()
                  : RubyString.newString(runtime, se.getAnchor());
          IRubyObject tag =
              se.getTag() == null ? runtime.getNil() : RubyString.newString(runtime, se.getTag());
          IRubyObject plain_implicit = runtime.newBoolean(se.getImplicit().isFirst());
          IRubyObject quoted_implicit = runtime.newBoolean(se.getImplicit().isSecond());
          IRubyObject style = runtime.newFixnum(se.getStyle());
          IRubyObject val = RubyString.newString(runtime, se.getValue());

          invoke(
              context, handler, "scalar", val, anchor, tag, plain_implicit, quoted_implicit, style);
        } else if (event.is(ID.SequenceStart)) {
          SequenceStartEvent sse = (SequenceStartEvent) event;
          IRubyObject anchor =
              sse.getAnchor() == null
                  ? runtime.getNil()
                  : RubyString.newString(runtime, sse.getAnchor());
          IRubyObject tag =
              sse.getTag() == null ? runtime.getNil() : RubyString.newString(runtime, sse.getTag());
          IRubyObject implicit = runtime.newBoolean(sse.getImplicit());
          IRubyObject style = runtime.newFixnum(sse.getFlowStyle() ? 1 : 0);

          invoke(context, handler, "start_sequence", anchor, tag, implicit, style);
        } else if (event.is(ID.SequenceEnd)) {
          invoke(context, handler, "end_sequence");
        } else if (event.is(ID.MappingStart)) {
          MappingStartEvent mse = (MappingStartEvent) event;
          IRubyObject anchor =
              mse.getAnchor() == null
                  ? runtime.getNil()
                  : RubyString.newString(runtime, mse.getAnchor());
          IRubyObject tag =
              mse.getTag() == null ? runtime.getNil() : RubyString.newString(runtime, mse.getTag());
          IRubyObject implicit = runtime.newBoolean(mse.getImplicit());
          IRubyObject style = runtime.newFixnum(mse.getFlowStyle() ? 1 : 0);

          invoke(context, handler, "start_mapping", anchor, tag, implicit, style);
        } else if (event.is(ID.MappingEnd)) {
          invoke(context, handler, "end_mapping");
        } else if (event.is(ID.StreamEnd)) {
          invoke(context, handler, "end_stream");
          break;
        }
      } catch (ParserException pe) {
        parser = null;
        RubyKernel.raise(
            context,
            runtime.getModule("Psych").getConstant("SyntaxError"),
            new IRubyObject[] {runtime.newString(pe.getLocalizedMessage())},
            Block.NULL_BLOCK);
      }
    }

    return this;
  }
Exemple #26
0
  public static IRubyObject createRubyHybridBacktrace(
      Ruby runtime,
      RubyStackTraceElement[] backtraceFrames,
      RubyStackTraceElement[] stackTrace,
      boolean debug) {
    RubyArray traceArray = RubyArray.newArray(runtime);
    ThreadContext context = runtime.getCurrentContext();

    int rubyFrameIndex = backtraceFrames.length - 1;
    for (int i = 0; i < stackTrace.length; i++) {
      RubyStackTraceElement element = stackTrace[i];

      // look for mangling markers for compiled Ruby in method name
      int index = element.getMethodName().indexOf("$RUBY$");
      if (index >= 0) {
        String unmangledMethod = element.getMethodName().substring(index + 6);
        RubyString str =
            RubyString.newString(
                runtime,
                element.getFileName()
                    + ":"
                    + element.getLineNumber()
                    + ":in `"
                    + unmangledMethod
                    + "'");
        traceArray.append(str);

        // if it's not a rescue or ensure, there's a frame associated, so decrement
        if (!(element.getMethodName().contains("__rescue__")
            || element.getMethodName().contains("__ensure__"))) {
          rubyFrameIndex--;
        }
        continue;
      }

      // look for __file__ method name for compiled roots
      if (element.getMethodName().equals("__file__")) {
        RubyString str =
            RubyString.newString(
                runtime, element.getFileName() + ":" + element.getLineNumber() + ": `<toplevel>'");
        traceArray.append(str);
        rubyFrameIndex--;
        continue;
      }

      // look for mangling markers for bound, unframed methods in class name
      index = element.getClassName().indexOf("$RUBYINVOKER$");
      if (index >= 0) {
        // unframed invokers have no Ruby frames, so pull from class name
        // but use current frame as file and line
        String unmangledMethod = element.getClassName().substring(index + 13);
        Frame current = context.frameStack[rubyFrameIndex];
        RubyString str =
            RubyString.newString(
                runtime,
                current.getFile()
                    + ":"
                    + (current.getLine() + 1)
                    + ":in `"
                    + unmangledMethod
                    + "'");
        traceArray.append(str);
        continue;
      }

      // look for mangling markers for bound, framed methods in class name
      index = element.getClassName().indexOf("$RUBYFRAMEDINVOKER$");
      if (index >= 0) {
        // framed invokers will have Ruby frames associated with them
        addBackTraceElement(
            traceArray,
            backtraceFrames[rubyFrameIndex],
            backtraceFrames[rubyFrameIndex - 1],
            FrameType.METHOD);
        rubyFrameIndex--;
        continue;
      }

      // try to mine out a Ruby frame using our list of interpreter entry-point markers
      String classMethod = element.getClassName() + "." + element.getMethodName();
      FrameType frameType = INTERPRETED_FRAMES.get(classMethod);
      if (frameType != null) {
        // Frame matches one of our markers for "interpreted" calls
        if (rubyFrameIndex == 0) {
          addBackTraceElement(
              traceArray,
              backtraceFrames[rubyFrameIndex],
              backtraceFrames[rubyFrameIndex],
              frameType);
        } else {
          addBackTraceElement(
              traceArray,
              backtraceFrames[rubyFrameIndex],
              backtraceFrames[rubyFrameIndex - 1],
              frameType);
          rubyFrameIndex--;
        }
        continue;
      } else {
        // Frame is extraneous runtime information, skip it unless debug
        if (debug) {
          RubyString str =
              RubyString.newString(runtime, createRubyBacktraceString(element.getElement()));
          traceArray.append(str);
        }
        continue;
      }
    }

    return traceArray;
  }
 private static IRubyObject number(Ruby runtime, int s) {
   return RubyString.newString(runtime, Pack.packInt_i(new ByteList(4), s));
 }
Exemple #28
0
  @JRubyMethod(name = "initialize", rest = true, frame = true)
  public IRubyObject _initialize(IRubyObject[] args, Block block) {
    extensions = new ArrayList<IRubyObject>();
    if (org.jruby.runtime.Arity.checkArgumentCount(getRuntime(), args, 0, 1) == 0) {
      version = getRuntime().getNil();
      issuer = getRuntime().getNil();
      last_update = getRuntime().getNil();
      next_update = getRuntime().getNil();
      revoked = getRuntime().newArray();
      return this;
    }

    ByteArrayInputStream bis = new ByteArrayInputStream(args[0].convertToString().getBytes());
    try {
      // SunJCE throws java.security.cert.CRLException: Invalid encoding of
      // AuthorityKeyIdentifierExtension.
      // FIXME: use BC for now.
      CertificateFactory cf = OpenSSLReal.getX509CertificateFactoryBC();
      crl = (java.security.cert.X509CRL) cf.generateCRL(bis);
    } catch (GeneralSecurityException gse) {
      throw newX509CRLError(getRuntime(), gse.getMessage());
    }

    byte[] crl_bytes = args[0].convertToString().getBytes();
    // Parse PEM if we ever get passed some PEM contents
    try {
      StringReader in = new StringReader(args[0].toString());
      byte[] bytes = OpenSSLReal.getFormatHandler().readPEMToDER(in);
      if (bytes != null) crl_bytes = bytes;
      in.close();
    } catch (Exception e) {
      // this is not PEM encoded, let's use the default argument
    }

    try {
      crl_v = new ASN1InputStream(new ByteArrayInputStream(crl_bytes)).readObject();
    } catch (IOException ioe) {
      throw newX509CRLError(getRuntime(), ioe.getMessage());
    }

    DEREncodable v0 = ((DERSequence) (((DERSequence) crl_v).getObjectAt(0))).getObjectAt(0);
    if (v0 instanceof DERInteger) {
      set_version(getRuntime().newFixnum(((DERInteger) v0).getValue().intValue()));
    } else {
      set_version(getRuntime().newFixnum(2));
    }
    set_last_update(RubyTime.newTime(getRuntime(), crl.getThisUpdate().getTime()));
    set_next_update(RubyTime.newTime(getRuntime(), crl.getNextUpdate().getTime()));
    RubyString name = RubyString.newString(getRuntime(), crl.getIssuerX500Principal().getEncoded());
    set_issuer(Utils.newRubyInstance(getRuntime(), "OpenSSL::X509::Name", name));

    revoked = getRuntime().newArray();

    DERSequence seqa = (DERSequence) ((DERSequence) crl_v).getObjectAt(0);
    DERObject maybe_ext = (DERObject) seqa.getObjectAt(seqa.size() - 1);
    if (maybe_ext instanceof DERTaggedObject && ((DERTaggedObject) maybe_ext).getTagNo() == 0) {
      DERSequence exts = (DERSequence) ((DERTaggedObject) maybe_ext).getObject();
      for (int i = 0; i < exts.size(); i++) {
        DERSequence seq2 = (DERSequence) exts.getObjectAt(i);
        boolean critical = false;
        String oid = ((DERObjectIdentifier) seq2.getObjectAt(0)).getId();
        if (seq2.getObjectAt(1) == DERBoolean.TRUE) {
          critical = true;
        }
        byte[] value = crl.getExtensionValue(oid);
        IRubyObject mASN1 = getRuntime().getClassFromPath("OpenSSL::ASN1");
        IRubyObject rValue = null;
        try {
          rValue =
              ASN1.decode(
                  mASN1,
                  ASN1.decode(mASN1, RubyString.newString(getRuntime(), value))
                      .callMethod(getRuntime().getCurrentContext(), "value"));
        } catch (Exception e) {
          rValue = RubyString.newString(getRuntime(), value);
        }
        X509Extensions.Extension ext1 =
            (X509Extensions.Extension)
                Utils.newRubyInstance(getRuntime(), "OpenSSL::X509::Extension");
        ext1.setRealOid(ext1.getObjectIdentifier(oid));
        ext1.setRealValue(rValue);
        ext1.setRealCritical(critical);
        add_extension(ext1);
      }
    }

    changed = false;
    return this;
  }