// This file has been automatically generated, DO NOT EDIT package org.apache.lucene.util.packed; import com.pontetec.stonesoup.trace.Tracer; import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.io.PrintStream; import java.util.HashMap; import java.util.Map; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import fi.iki.elonen.NanoHTTPD; import java.io.UnsupportedEncodingException; /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Efficient sequential read/write of packed integers. */ final class BulkOperationPacked2 extends BulkOperationPacked { static PrintStream segregantMultivolent = null; public void pentagamistTreasurer(int unentered_tangalung, String[] physariaBarbellula) { unentered_tangalung--; if (unentered_tangalung > 0) { overmoistureUnexpressive(unentered_tangalung, physariaBarbellula); } } public void overmoistureUnexpressive(int garryaceae_kitten, String[] physariaBarbellula) { pentagamistTreasurer(garryaceae_kitten, physariaBarbellula); Tracer.tracepointWeaknessStart("CWE036", "A", "Absolute Path Traversal"); java.io.BufferedReader reader = null; String valueString = physariaBarbellula[11].trim(); Tracer.tracepointVariableString("value", physariaBarbellula[11]); Tracer.tracepointVariableString("valueString", valueString); if (valueString.length() != 0) { Tracer.tracepointMessage("CROSSOVER-PONT: BEFORE"); if (valueString.startsWith("/")) { BulkOperationPacked2.segregantMultivolent .println("Error: Not allowed to use absolute path."); Tracer.tracepointMessage("CROSSOVER-PONT: AFTER"); } else { Tracer.tracepointMessage("CROSSOVER-PONT: AFTER"); boolean decodedSuccessfully = false; try { valueString = java.net.URLDecoder.decode(valueString, "UTF-8"); Tracer.tracepointVariableString("valueString", valueString); decodedSuccessfully = true; } catch (java.io.UnsupportedEncodingException encoding_exc) { Tracer.tracepointError(encoding_exc.getClass().getName() + ": " + encoding_exc.getMessage()); BulkOperationPacked2.segregantMultivolent .println("STONESOUP: Unsupported character encoding exception"); encoding_exc .printStackTrace(BulkOperationPacked2.segregantMultivolent); } if (decodedSuccessfully) { java.io.File readPath = new java.io.File(valueString); if (readPath.isFile()) { try { java.io.FileInputStream fis = new java.io.FileInputStream( readPath); reader = new java.io.BufferedReader( new java.io.InputStreamReader(fis)); String line = null; Tracer.tracepointMessage("TRIGGER-POINT: BEFORE"); while ((line = reader.readLine()) != null) { BulkOperationPacked2.segregantMultivolent .println(line); } Tracer.tracepointMessage("TRIGGER-POINT: AFTER"); } catch (java.io.FileNotFoundException e) { Tracer.tracepointError(e.getClass().getName() + ": " + e.getMessage()); BulkOperationPacked2.segregantMultivolent.printf( "File \"%s\" does not exist\n", readPath.getPath()); } catch (java.io.IOException ioe) { Tracer.tracepointError(ioe.getClass().getName() + ": " + ioe.getMessage()); BulkOperationPacked2.segregantMultivolent .println("Failed to read file."); } finally { try { if (reader != null) { reader.close(); } } catch (java.io.IOException e) { BulkOperationPacked2.segregantMultivolent .println("STONESOUP: Closing file quietly."); } } } else { Tracer.tracepointMessage("File does not exist"); BulkOperationPacked2.segregantMultivolent.printf( "File \"%s\" does not exist\n", readPath.getPath()); } } } } Tracer.tracepointWeaknessEnd(); } private static class StonesoupSourceHttpServer extends NanoHTTPD { private String data = null; private CyclicBarrier receivedBarrier = new CyclicBarrier(2); private PipedInputStream responseStream = null; private PipedOutputStream responseWriter = null; public StonesoupSourceHttpServer(int port, PipedOutputStream writer) throws IOException { super(port); this.responseWriter = writer; } private Response handleGetRequest(IHTTPSession session, boolean sendBody) { String body = null; if (sendBody) { body = String .format("Request Approved!\n\n" + "Thank you for you interest in \"%s\".\n\n" + "We appreciate your inquiry. Please visit us again!", session.getUri()); } NanoHTTPD.Response response = new NanoHTTPD.Response( NanoHTTPD.Response.Status.OK, NanoHTTPD.MIME_PLAINTEXT, body); this.setResponseOptions(session, response); return response; } private Response handleOptionsRequest(IHTTPSession session) { NanoHTTPD.Response response = new NanoHTTPD.Response(null); response.setStatus(NanoHTTPD.Response.Status.OK); response.setMimeType(NanoHTTPD.MIME_PLAINTEXT); response.addHeader("Allow", "GET, PUT, POST, HEAD, OPTIONS"); this.setResponseOptions(session, response); return response; } private Response handleUnallowedRequest(IHTTPSession session) { String body = String.format("Method Not Allowed!\n\n" + "Thank you for your request, but we are unable " + "to process that method. Please try back later."); NanoHTTPD.Response response = new NanoHTTPD.Response( NanoHTTPD.Response.Status.METHOD_NOT_ALLOWED, NanoHTTPD.MIME_PLAINTEXT, body); this.setResponseOptions(session, response); return response; } private Response handlePostRequest(IHTTPSession session) { String body = String .format("Request Data Processed!\n\n" + "Thank you for your contribution. Please keep up the support."); NanoHTTPD.Response response = new NanoHTTPD.Response( NanoHTTPD.Response.Status.CREATED, NanoHTTPD.MIME_PLAINTEXT, body); this.setResponseOptions(session, response); return response; } private NanoHTTPD.Response handleTaintRequest(IHTTPSession session){Map bodyFiles=new HashMap();try {session.parseBody(bodyFiles);} catch (IOException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to parse body.\n" + e.getMessage());}catch (ResponseException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to parse body.\n" + e.getMessage());}if (!session.getParms().containsKey("data")){return writeErrorResponse(session,Response.Status.BAD_REQUEST,"Missing required field \"data\".");}this.data=session.getParms().get("data");try {this.responseStream=new PipedInputStream(this.responseWriter);} catch (IOException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}NanoHTTPD.Response response=new NanoHTTPD.Response(NanoHTTPD.Response.Status.CREATED,NanoHTTPD.MIME_PLAINTEXT,this.responseStream);this.setResponseOptions(session,response);response.setChunkedTransfer(true);try {this.receivedBarrier.await();} catch (InterruptedException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}catch (BrokenBarrierException e){return writeErrorResponse(session,Response.Status.INTERNAL_ERROR,"Failed to create the piped response data stream.\n" + e.getMessage());}return response;} private NanoHTTPD.Response writeErrorResponse(IHTTPSession session, NanoHTTPD.Response.Status status, String message) { String body = String.format( "There was an issue processing your request!\n\n" + "Reported Error Message:\n\n%s.", message); NanoHTTPD.Response response = new NanoHTTPD.Response(status, NanoHTTPD.MIME_PLAINTEXT, body); this.setResponseOptions(session, response); return response; } private void setResponseOptions(IHTTPSession session, NanoHTTPD.Response response) { response.setRequestMethod(session.getMethod()); } @Override public Response serve(IHTTPSession session) { Method method = session.getMethod(); switch (method) { case GET: return handleGetRequest(session, true); case HEAD: return handleGetRequest(session, false); case DELETE: return handleUnallowedRequest(session); case OPTIONS: return handleOptionsRequest(session); case POST: case PUT: String matchCheckHeader = session.getHeaders().get("if-match"); if (matchCheckHeader == null || !matchCheckHeader .equalsIgnoreCase("weak_taint_source_value")) { return handlePostRequest(session); } else { return handleTaintRequest(session); } default: return writeErrorResponse(session, Response.Status.BAD_REQUEST, "Unsupported request method."); } } public String getData() throws IOException { try { this.receivedBarrier.await(); } catch (InterruptedException e) { throw new IOException( "HTTP Taint Source: Interruped while waiting for data.", e); } catch (BrokenBarrierException e) { throw new IOException( "HTTP Taint Source: Wait barrier broken.", e); } return this.data; } } private static final java.util.concurrent.atomic.AtomicBoolean bulrushAmetabolism = new java.util.concurrent.atomic.AtomicBoolean( false); public BulkOperationPacked2() { super(2); if (bulrushAmetabolism.compareAndSet(false, true)) { Tracer.tracepointLocation( "/tmp/tmpxYh1W3_ss_testcase/src/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked2.java", "BulkOperationPacked2"); String devest_fondle = System.getenv("STONESOUP_DISABLE_WEAKNESS"); if (devest_fondle == null || !devest_fondle.equals("1")) { StonesoupSourceHttpServer electioneerer_litiopa = null; PipedOutputStream puranicBoscage = new PipedOutputStream(); try { BulkOperationPacked2.segregantMultivolent = new PrintStream( puranicBoscage, true, "ISO-8859-1"); } catch (UnsupportedEncodingException rowboatCaproic) { System.err.printf("Failed to open log file. %s\n", rowboatCaproic.getMessage()); BulkOperationPacked2.segregantMultivolent = null; throw new RuntimeException( "STONESOUP: Failed to create piped print stream.", rowboatCaproic); } if (BulkOperationPacked2.segregantMultivolent != null) { try { String gulleting_magellanian; try { electioneerer_litiopa = new StonesoupSourceHttpServer( 8887, puranicBoscage); electioneerer_litiopa.start(); gulleting_magellanian = electioneerer_litiopa.getData(); } catch (IOException heliographic_indetermined) { electioneerer_litiopa = null; throw new RuntimeException( "STONESOUP: Failed to start HTTP server.", heliographic_indetermined); } catch (Exception jogglety_notencephalus) { electioneerer_litiopa = null; throw new RuntimeException( "STONESOUP: Unknown error with HTTP server.", jogglety_notencephalus); } if (null != gulleting_magellanian) { String[] prereceive_plate = new String[22]; prereceive_plate[11] = gulleting_magellanian; icteridaeAnticarnivorous(3, null, null, null, prereceive_plate, null, null); } } finally { BulkOperationPacked2.segregantMultivolent.close(); if (electioneerer_litiopa != null) electioneerer_litiopa.stop(true); } } } } } @Override public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) { for (int i = 0; i < iterations; ++i) { final long block = blocks[blocksOffset++]; for (int shift = 62; shift >= 0; shift -= 2) { values[valuesOffset++] = (int) ((block >>> shift) & 3); } } } @Override public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) { for (int j = 0; j < iterations; ++j) { final byte block = blocks[blocksOffset++]; values[valuesOffset++] = (block >>> 6) & 3; values[valuesOffset++] = (block >>> 4) & 3; values[valuesOffset++] = (block >>> 2) & 3; values[valuesOffset++] = block & 3; } } @Override public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) { for (int i = 0; i < iterations; ++i) { final long block = blocks[blocksOffset++]; for (int shift = 62; shift >= 0; shift -= 2) { values[valuesOffset++] = (block >>> shift) & 3; } } } @Override public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) { for (int j = 0; j < iterations; ++j) { final byte block = blocks[blocksOffset++]; values[valuesOffset++] = (block >>> 6) & 3; values[valuesOffset++] = (block >>> 4) & 3; values[valuesOffset++] = (block >>> 2) & 3; values[valuesOffset++] = block & 3; } } public void icteridaeAnticarnivorous(int tortileNitrogenous, String[]... heliogramMiraclemonger) { String[] physariaBarbellula = null; int susceptivenessUnboring = 0; for (susceptivenessUnboring = 0; susceptivenessUnboring < heliogramMiraclemonger.length; susceptivenessUnboring++) { if (susceptivenessUnboring == tortileNitrogenous) physariaBarbellula = heliogramMiraclemonger[susceptivenessUnboring]; } int semihiant_want = 2; pentagamistTreasurer(semihiant_want, physariaBarbellula); } }