/FileExtraction/Java_unseen/dlitz_resin/modules/quercus/src/com/caucho/quercus/lib/OutputModule.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.quercus.lib;

import com.caucho.quercus.annotation.Optional;
import com.caucho.quercus.env.*;
import com.caucho.quercus.module.AbstractQuercusModule;
import com.caucho.quercus.module.ModuleStartupListener;
import com.caucho.quercus.module.IniDefinitions;
import com.caucho.quercus.module.IniDefinition;
import com.caucho.util.L10N;
import com.caucho.vfs.StreamImplOutputStream;
import com.caucho.vfs.TempStream;
import com.caucho.vfs.TempBuffer;

import java.io.IOException;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.logging.Logger;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;

/**
 * PHP output routines.
 */
public class OutputModule extends AbstractQuercusModule 
  implements ModuleStartupListener {
  private static final L10N L = new L10N(OutputModule.class);
  private static final Logger log = Logger.getLogger(
      OutputModule.class.getName());

  private static final StringValue HTTP_ACCEPT_ENCODING
    = new ConstStringValue("HTTP_ACCEPT_ENCODING");

  private static final IniDefinitions _iniDefinitions = new IniDefinitions();

  // ob_gzhandler related variables/types
  private enum Encoding { NONE, GZIP, DEFLATE };

  private static class GZOutputPair {
    public StringBuilderOutputStream _tempStream;
    public OutputStream _outputStream;
  }

  private static HashMap<Env,GZOutputPair> _gzOutputPairs 
    = new HashMap<Env,GZOutputPair>();

  public static final int PHP_OUTPUT_HANDLER_START = 1;
  public static final int PHP_OUTPUT_HANDLER_CONT = 2;
  public static final int PHP_OUTPUT_HANDLER_END = 4;
  
  /**
   * Returns the default php.ini values.
   */
  public IniDefinitions getIniDefinitions()
  {
    return _iniDefinitions;
  }

  public void startup(Env env)
  {
    boolean isOutputBuffering = INI_OUTPUT_BUFFERING.getAsBoolean(env);
    String handlerName = INI_OUTPUT_HANDLER.getAsString(env);

    if (handlerName != null
        && ! "".equals(handlerName)
        && env.getFunction(handlerName) != null) {
      Callable callback = env.createString(handlerName).toCallable(env);

      ob_start(env, callback, 0, true);
    } else if (isOutputBuffering) {
      ob_start(env, null, 0, true);
    }

    ob_implicit_flush(env, isOutputBuffering);
  }

  /**
   * Flushes the original output buffer.
   */
  public Value flush(Env env)
  {
    try {
      // XXX: conflicts with dragonflycms install
      env.getOriginalOut().flush();
    } catch (IOException e) {
    }

    return NullValue.NULL;
  }

  /**
   * Clears the output buffer.
   */
  public static Value ob_clean(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null) {
      ob.clean();

      return BooleanValue.TRUE;
    }
    else
      return BooleanValue.FALSE;
  }

  /**
   * Pops the output buffer, discarding the contents.
   */
  public static boolean ob_end_clean(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null) {
      ob.clean();

      Callable callback = ob.getCallback();

      if (callback != null) {
        ob.setCallback(null);
      }
    }

    return env.popOutputBuffer();
  }

  /**
   * Pops the output buffer.
   */
  public static boolean ob_end_flush(Env env)
  {
    return env.popOutputBuffer();
  }

  /**
   * Returns the contents of the output buffer, emptying it afterwards.
   * From the PHP Docs:
   *  Gets the current buffer contents and delete current output buffer.
   *  ob_get_clean() essentially executes both ob_get_contents() and ob_end_clean()
   */
  public static Value ob_get_clean(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null) {
      Value result = ob.getContents();

      ob_end_clean(env);

      return result;
    }
    else
      return BooleanValue.FALSE;
  }

  /**
   * Returns the contents of the current output buffer.
   */
  public static Value ob_get_contents(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null)
      return ob.getContents();
    else
      return BooleanValue.FALSE;
  }

  /**
   * Pops the output buffer and returns the contents.
   */
  public static Value ob_get_flush(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    Value result = BooleanValue.FALSE;
    if (ob != null) {
      result = ob.getContents();
    }

    env.popOutputBuffer();

    return result;
  }

  /**
   * Flushes this output buffer into the next one on the stack or
   * to the default "output buffer" if no next output buffer exists.
   * The callback associated with this buffer is also called with
   * appropriate parameters.
   */
  public static Value ob_flush(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null) {
      ob.flush();

      return BooleanValue.TRUE;
    } 
    else
      return BooleanValue.FALSE;
  }

  /**
   * Pushes the output buffer
   */
  public static Value ob_get_length(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null)
      return LongValue.create(ob.getLength());
    else
      return BooleanValue.FALSE;
  }

  /**
   * Gets the nesting level of the current output buffer
   */
  public static Value ob_get_level(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();

    if (ob != null)
      return LongValue.create(ob.getLevel());
    else
      return LongValue.ZERO;
  }

  /**
   * Helper recursive function that ensures the handlers are listed
   * in the correct order in the array.
   */
  private static void listHandlers(Env env,
                                   OutputBuffer ob,
                                   ArrayValue handlers)
  {
    if (ob == null)
      return;

    listHandlers(env, ob.getNext(), handlers);

    Callable callback = ob.getCallback();

    if (callback != null) 
      handlers.put(env.createString(callback.getCallbackName()));
    else
      handlers.put(env.createString("default output handler"));
  }
  
  /**
   * Returns a list of all the output handlers in use.
   */
  public static Value ob_list_handlers(Env env)
  {
    OutputBuffer ob = env.getOutputBuffer();
    ArrayValue handlers = new ArrayValueImpl();

    listHandlers(env, ob, handlers);

    return handlers;
  }

  /**
   * Inserts the common values for ob_get_status into an array.  Used
   * by getFullStatus() and ob_get_status().
   */
  private static void putCommonStatus(ArrayValue element, OutputBuffer ob,
                                      Env env, boolean fullStatus)
  {
    LongValue type = LongValue.ONE;
    Callable callback = ob.getCallback();

    // XXX: need to replace logic because isInternal appears to be
    // specific to ob_, not general to Callback
    /*
    if (callback != null && callback.isInternal())
      type = LongValue.ZERO;
      */

    String name;

    if (callback != null)
      name = callback.getCallbackName();
    else
      name = "default output handler".intern();
    
    // XXX: there appears to be only one "internal" callback
    if (name.equals("URL-Rewriter"))
      type = LongValue.ZERO;
    
    element.put(env.createString("type"), type);

    // the rewriter is a special case where it includes a field
    // "buffer_size" right in the middle of the common elements, 
    // but only when called with full status.  It appears always 
    // to be 0 and there is no interface to change this buffer_size
    // and no indication of its meaning.
    if (fullStatus && callback != null
        && callback == UrlRewriterCallback.getInstance(env))
      element.put(env.createString("buffer_size"), LongValue.ZERO);

    // Technically, there are supposed to be three possible values
    // for status: 
    //   0 if the stream has never been flushed (PHP_OUTPUT_HANDLER_START)
    //   1 if the stream has been flushed (PHP_OUTPUT_HANDLER_CONT)
    //   2 if the stream was flushed at the end (PHP_OUTPUT_HANDLER_END)
    // However, there is no way to access the buffer after it has ended, 
    // so the final case doesn't seem to be an issue!  (Even calling
    // ob_get_status() in the handler on a ob_end_flush() does not
    // invoke this state.)
    LongValue status = ob.haveFlushed() ? LongValue.ONE : LongValue.ZERO;
    element.put(env.createString("status"), status);

    StringValue nameV = env.createString(name);

    element.put(env.createString("name".intern()), nameV);

    Value del = ob.getEraseFlag() ? BooleanValue.TRUE
        : BooleanValue.FALSE;
    
    element.put(env.createString("del"), del);
  }

  /**
   * Gets the status for all the output buffers on the stack.
   * Recursion ensures the results are ordered correctly in the array.
   */
  private static void getFullStatus(OutputBuffer ob, Env env, ArrayValue result)
  {
    if (ob == null)
      return;

    getFullStatus(ob.getNext(), env, result);

    ArrayValue element = new ArrayValueImpl();

    element.put(env.createString("chunk_size"),
                LongValue.create(ob.getChunkSize()));
    
    // XXX: Not sure why we even need to list a size -- PHP doesn't 
    // even seem to respect it.  -1 => infinity?  
    // (Note: "size" == "capacity")
    element.put(env.createString("size"), LongValue.create(-1));
    element.put(env.createString("block_size"), LongValue.create(-1));

    putCommonStatus(element, ob, env, true);
   
    result.put(element);
  }

  /**
   * Gets the status of the current output buffer(s)
   */ 
  public static Value ob_get_status(Env env, @Optional boolean full_status)
  {
    if (full_status) {
      OutputBuffer ob = env.getOutputBuffer();
      ArrayValue result = new ArrayValueImpl();

      getFullStatus(ob, env, result);

      return result;
    }

    OutputBuffer ob = env.getOutputBuffer();
    ArrayValue result = new ArrayValueImpl();

    if (ob != null) {
      result.put(env.createString("level"),
                 LongValue.create(ob.getLevel()));

      putCommonStatus(result, ob, env, false);
    }

    // returns an empty array when no output buffer exists
    return result;
  }

  /**
   * Makes the original "output buffer" flush on every write.
   */
  public static Value ob_implicit_flush(Env env, @Optional("true") boolean flag)
  {
    if (env.getOriginalOut() != null)
      env.getOriginalOut().setImplicitFlush(flag);

    return NullValue.NULL;
  }

  /**
   * Pushes the output buffer
   */
  public static boolean ob_start(Env env,
                                 @Optional Callable callback,
                                 @Optional int chunkSize,
                                 @Optional("true") boolean erase)
  {
    if (callback != null
        && callback.getCallbackName().equals("ob_gzhandler")) {
      OutputBuffer ob = env.getOutputBuffer();

      for (; ob != null; ob = ob.getNext()) {
        Callable cb = ob.getCallback();

        if (cb.getCallbackName().equals("ob_gzhandler")) {
          env.warning(
              L.l("output handler 'ob_gzhandler' cannot be used twice"));
          return false;
        }
      }
    }
    
    env.pushOutputBuffer(callback, chunkSize, erase);

    return true;
  }

  /**
   * Pushes a new UrlRewriter callback onto the output buffer stack
   * if one does not already exist.
   */
  public static UrlRewriterCallback pushUrlRewriter(Env env)
  {
    UrlRewriterCallback rewriter = UrlRewriterCallback.getInstance(env);

    if (rewriter == null) {
      OutputBuffer ob = env.getOutputBuffer();
      rewriter = new UrlRewriterCallback(env);

      // PHP installs the URL rewriter into the top output buffer if
      // its callback is null
      if (ob != null && ob.getCallback() == null)
        ob.setCallback(rewriter);
      else 
        ob_start(env, rewriter, 0, true);
    }

    return rewriter;
  }

  /**
   * Adds a variable to the list for rewritten URLs.
   */
  public static boolean output_add_rewrite_var(Env env, 
                                               String name, String value)
  {
    UrlRewriterCallback rewriter = pushUrlRewriter(env);
   
    rewriter.addRewriterVar(name, value);

    return true;
  }

  /**
   * Clears the list of variables for rewritten URLs.
   */
  public static boolean output_reset_rewrite_vars(Env env)
  {
    UrlRewriterCallback rewriter = UrlRewriterCallback.getInstance(env); 

    rewriter.resetRewriterVars();

    return true;
  }

  /**
   * Output buffering compatible callback that automatically compresses
   * the output.  The output of this function depends on the value of 
   * state.  Specifically, if the PHP_OUTPUT_HANDLER_START bit is on
   * in the state field, the function supplies a header with the output
   * and initializes a gzip/deflate stream which will be used for 
   * subsequent calls.
   */
  public static Value ob_gzhandler(Env env, StringValue buffer, int state)
  {
    Encoding encoding = Encoding.NONE;
    Value _SERVER = env.getGlobalVar("_SERVER");

    String [] acceptedList
      = _SERVER.get(HTTP_ACCEPT_ENCODING).toString().split(",");

    for (String accepted : acceptedList) {
      accepted = accepted.trim();

      if (accepted.equalsIgnoreCase("gzip")) {
        encoding = Encoding.GZIP;
        break;
      } else if (accepted.equalsIgnoreCase("deflate")) {
        encoding = Encoding.DEFLATE;
        break;
      }
    }

    if (encoding == Encoding.NONE)
      return BooleanValue.FALSE;

    GZOutputPair pair = null;

    StringValue result = env.createBinaryBuilder();
    
    if ((state & (PHP_OUTPUT_HANDLER_START)) != 0) {
      HttpModule.header(
          env, env.createString("Vary: Accept-Encoding"), true, 0);

      int encodingFlag = 0;

      pair = new GZOutputPair();
      pair._tempStream = new StringBuilderOutputStream(result);
      pair._tempStream.setStringBuilder(result);

      try {
        if (encoding == Encoding.GZIP) {
          HttpModule.header(
              env, env.createString("Content-Encoding: gzip"), true, 0);

          pair._outputStream = new GZIPOutputStream(pair._tempStream);
        } else if (encoding == Encoding.DEFLATE) {
          HttpModule.header(
              env, env.createString("Content-Encoding: deflate"), true, 0);

          pair._outputStream = new DeflaterOutputStream(pair._tempStream);
        }
      } catch (IOException e) {
        return BooleanValue.FALSE;
      }

      env.setGzStream(pair);
    } else {
      pair = (GZOutputPair) env.getGzStream();
      
      if (pair == null)
        return BooleanValue.FALSE;
      
      pair._tempStream.setStringBuilder(result);
    }
    
    try {
      buffer.writeTo(pair._outputStream);
      pair._outputStream.flush();

      if ((state & (PHP_OUTPUT_HANDLER_END)) != 0) {
        pair._outputStream.close();
      }
    } catch (IOException e) {
      return BooleanValue.FALSE;
    }

    pair._tempStream.setStringBuilder(null);

    return result;
  }

  static final IniDefinition INI_OUTPUT_BUFFERING
    = _iniDefinitions.add("output_buffering", false, PHP_INI_PERDIR);
  static final IniDefinition INI_OUTPUT_HANDLER
    = _iniDefinitions.add("output_handler", "", PHP_INI_PERDIR);
  static final IniDefinition INI_IMPLICIT_FLUSH
    = _iniDefinitions.add("implicit_flush", false, PHP_INI_ALL);
}
