CSE2410 Fall 2014 Bounce

// Copyright 2008 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <v8.h>

#include <string>

#include <map>

using namespace std;

using namespace v8;

// These interfaces represent an existing request processing interface.

// The idea is to imagine a real application that uses these interfaces

// and then add scripting capabilities that allow you to interact with

// the objects through JavaScript.

/**

 * A simplified http request.

 */

class HttpRequest {

 public:

  virtual ~HttpRequest() { }

  virtual const string& Path() = 0;

  virtual const string& Referrer() = 0;

  virtual const string& Host() = 0;

  virtual const string& UserAgent() = 0;

};

/**

 * The abstract superclass of http request processors.

 */

class HttpRequestProcessor {

 public:

  virtual ~HttpRequestProcessor() { }

  // Initialize this processor.  The map contains options that control

  // how requests should be processed.

  virtual bool Initialize(map<string, string>* options,

                          map<string, string>* output) = 0;

  // Process a single request.

  virtual bool Process(HttpRequest* req) = 0;

  static void Log(const char* event);

};

/**

 * An http request processor that is scriptable using JavaScript.

 */

class JsHttpRequestProcessor : public HttpRequestProcessor {

 public:

  // Creates a new processor that processes requests by invoking the

  // Process function of the JavaScript script given as an argument.

  explicit JsHttpRequestProcessor(Handle<String> script) : script_(script) { }

  virtual ~JsHttpRequestProcessor();

  virtual bool Initialize(map<string, string>* opts,

                          map<string, string>* output);

  virtual bool Process(HttpRequest* req);

 private:

  // Execute the script associated with this processor and extract the

  // Process function.  Returns true if this succeeded, otherwise false.

  bool ExecuteScript(Handle<String> script);

  // Wrap the options and output map in a JavaScript objects and

  // install it in the global namespace as 'options' and 'output'.

  bool InstallMaps(map<string, string>* opts, map<string, string>* output);

  // Constructs the template that describes the JavaScript wrapper

  // type for requests.

  static Handle<ObjectTemplate> MakeRequestTemplate();

  static Handle<ObjectTemplate> MakeMapTemplate();

  // Callbacks that access the individual fields of request objects.

  static Handle<Value> GetPath(Local<String> name, const AccessorInfo& info);

  static Handle<Value> GetReferrer(Local<String> name,

                                   const AccessorInfo& info);

  static Handle<Value> GetHost(Local<String> name, const AccessorInfo& info);

  static Handle<Value> GetUserAgent(Local<String> name,

                                    const AccessorInfo& info);

  // Callbacks that access maps

  static Handle<Value> MapGet(Local<String> name, const AccessorInfo& info);

  static Handle<Value> MapSet(Local<String> name,

                              Local<Value> value,

                              const AccessorInfo& info);

  // Utility methods for wrapping C++ objects as JavaScript objects,

  // and going back again.

  static Handle<Object> WrapMap(map<string, string>* obj);

  static map<string, string>* UnwrapMap(Handle<Object> obj);

  static Handle<Object> WrapRequest(HttpRequest* obj);

  static HttpRequest* UnwrapRequest(Handle<Object> obj);

  Handle<String> script_;

  Persistent<Context> context_;

  Persistent<Function> process_;

  static Persistent<ObjectTemplate> request_template_;

  static Persistent<ObjectTemplate> map_template_;

};

// -------------------------

// --- P r o c e s s o r ---

// -------------------------

static Handle<Value> LogCallback(const Arguments& args) {

  if (args.Length() < 1) return v8::Undefined();

  HandleScope scope;

  Handle<Value> arg = args[0];

  String::Utf8Value value(arg);

  HttpRequestProcessor::Log(*value);

  return v8::Undefined();

}

// Execute the script and fetch the Process method.

bool JsHttpRequestProcessor::Initialize(map<string, string>* opts,

                                        map<string, string>* output) {

  // Create a handle scope to hold the temporary references.

  HandleScope handle_scope;

  // Create a template for the global object where we set the

  // built-in global functions.

  Handle<ObjectTemplate> global = ObjectTemplate::New();

  global->Set(String::New("log"), FunctionTemplate::New(LogCallback));

  // Each processor gets its own context so different processors

  // don't affect each other (ignore the first three lines).

  Handle<Context> context = Context::New(NULL, global);

  // Store the context in the processor object in a persistent handle,

  // since we want the reference to remain after we return from this

  // method.

  context_ = Persistent<Context>::New(context);

  // Enter the new context so all the following operations take place

  // within it.

  Context::Scope context_scope(context);

  // Make the options mapping available within the context

  if (!InstallMaps(opts, output))

    return false;

  // Compile and run the script

  if (!ExecuteScript(script_))

    return false;

  // The script compiled and ran correctly.  Now we fetch out the

  // Process function from the global object.

  Handle<String> process_name = String::New("Process");

  Handle<Value> process_val = context->Global()->Get(process_name);

  // If there is no Process function, or if it is not a function,

  // bail out

  if (!process_val->IsFunction()) return false;

  // It is a function; cast it to a Function

  Handle<Function> process_fun = Handle<Function>::Cast(process_val);

  // Store the function in a Persistent handle, since we also want

  // that to remain after this call returns

  process_ = Persistent<Function>::New(process_fun);

  // All done; all went well

  return true;

}

bool JsHttpRequestProcessor::ExecuteScript(Handle<String> script) {

  HandleScope handle_scope;

  // We're just about to compile the script; set up an error handler to

  // catch any exceptions the script might throw.

  TryCatch try_catch;

  // Compile the script and check for errors.

  Handle<Script> compiled_script = Script::Compile(script);

  if (compiled_script.IsEmpty()) {

    String::Utf8Value error(try_catch.Exception());

    Log(*error);

    // The script failed to compile; bail out.

    return false;

  }

  // Run the script!

  Handle<Value> result = compiled_script->Run();

  if (result.IsEmpty()) {

    // The TryCatch above is still in effect and will have caught the error.

    String::Utf8Value error(try_catch.Exception());

    Log(*error);

    // Running the script failed; bail out.

    return false;

  }

  return true;

}

bool JsHttpRequestProcessor::InstallMaps(map<string, string>* opts,

                                         map<string, string>* output) {

  HandleScope handle_scope;

  // Wrap the map object in a JavaScript wrapper

  Handle<Object> opts_obj = WrapMap(opts);

  // Set the options object as a property on the global object.

  context_->Global()->Set(String::New("options"), opts_obj);

  Handle<Object> output_obj = WrapMap(output);

  context_->Global()->Set(String::New("output"), output_obj);

  return true;

}

bool JsHttpRequestProcessor::Process(HttpRequest* request) {

  // Create a handle scope to keep the temporary object references.

  HandleScope handle_scope;

  // Enter this processor's context so all the remaining operations

  // take place there

  Context::Scope context_scope(context_);

  // Wrap the C++ request object in a JavaScript wrapper

  Handle<Object> request_obj = WrapRequest(request);

  // Set up an exception handler before calling the Process function

  TryCatch try_catch;

  // Invoke the process function, giving the global object as 'this'

  // and one argument, the request.

  const int argc = 1;

  Handle<Value> argv[argc] = { request_obj };

  Handle<Value> result = process_->Call(context_->Global(), argc, argv);

  if (result.IsEmpty()) {

    String::Utf8Value error(try_catch.Exception());

    Log(*error);

    return false;

  } else {

    return true;

  }

}

JsHttpRequestProcessor::~JsHttpRequestProcessor() {

  // Dispose the persistent handles.  When noone else has any

  // references to the objects stored in the handles they will be

  // automatically reclaimed.

  context_.Dispose();

  process_.Dispose();

}

Persistent<ObjectTemplate> JsHttpRequestProcessor::request_template_;

Persistent<ObjectTemplate> JsHttpRequestProcessor::map_template_;

// -----------------------------------

// --- A c c e s s i n g   M a p s ---

// -----------------------------------

// Utility function that wraps a C++ http request object in a

// JavaScript object.

Handle<Object> JsHttpRequestProcessor::WrapMap(map<string, string>* obj) {

  // Handle scope for temporary handles.

  HandleScope handle_scope;

  // Fetch the template for creating JavaScript map wrappers.

  // It only has to be created once, which we do on demand.

  if (request_template_.IsEmpty()) {

    Handle<ObjectTemplate> raw_template = MakeMapTemplate();

    map_template_ = Persistent<ObjectTemplate>::New(raw_template);

  }

  Handle<ObjectTemplate> templ = map_template_;

  // Create an empty map wrapper.

  Handle<Object> result = templ->NewInstance();

  // Wrap the raw C++ pointer in an External so it can be referenced

  // from within JavaScript.

  Handle<External> map_ptr = External::New(obj);

  // Store the map pointer in the JavaScript wrapper.

  result->SetInternalField(0, map_ptr);

  // Return the result through the current handle scope.  Since each

  // of these handles will go away when the handle scope is deleted

  // we need to call Close to let one, the result, escape into the

  // outer handle scope.

  return handle_scope.Close(result);

}

// Utility function that extracts the C++ map pointer from a wrapper

// object.

map<string, string>* JsHttpRequestProcessor::UnwrapMap(Handle<Object> obj) {

  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));

  void* ptr = field->Value();

  return static_cast<map<string, string>*>(ptr);

}

// Convert a JavaScript string to a std::string.  To not bother too

// much with string encodings we just use ascii.

string ObjectToString(Local<Value> value) {

  String::Utf8Value utf8_value(value);

  return string(*utf8_value);

}

Handle<Value> JsHttpRequestProcessor::MapGet(Local<String> name,

                                             const AccessorInfo& info) {

  // Fetch the map wrapped by this object.

  map<string, string>* obj = UnwrapMap(info.Holder());

  // Convert the JavaScript string to a std::string.

  string key = ObjectToString(name);

  // Look up the value if it exists using the standard STL ideom.

  map<string, string>::iterator iter = obj->find(key);

  // If the key is not present return an empty handle as signal

  if (iter == obj->end()) return Handle<Value>();

  // Otherwise fetch the value and wrap it in a JavaScript string

  const string& value = (*iter).second;

  return String::New(value.c_str(), value.length());

}

Handle<Value> JsHttpRequestProcessor::MapSet(Local<String> name,

                                             Local<Value> value_obj,

                                             const AccessorInfo& info) {

  // Fetch the map wrapped by this object.

  map<string, string>* obj = UnwrapMap(info.Holder());

  // Convert the key and value to std::strings.

  string key = ObjectToString(name);

  string value = ObjectToString(value_obj);

  // Update the map.

  (*obj)[key] = value;

  // Return the value; any non-empty handle will work.

  return value_obj;

}

Handle<ObjectTemplate> JsHttpRequestProcessor::MakeMapTemplate() {

  HandleScope handle_scope;

  Handle<ObjectTemplate> result = ObjectTemplate::New();

  result->SetInternalFieldCount(1);

  result->SetNamedPropertyHandler(MapGet, MapSet);

  // Again, return the result through the current handle scope.

  return handle_scope.Close(result);

}

// -------------------------------------------

// --- A c c e s s i n g   R e q u e s t s ---

// -------------------------------------------

/**

 * Utility function that wraps a C++ http request object in a

 * JavaScript object.

 */

Handle<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) {

  // Handle scope for temporary handles.

  HandleScope handle_scope;

  // Fetch the template for creating JavaScript http request wrappers.

  // It only has to be created once, which we do on demand.

  if (request_template_.IsEmpty()) {

    Handle<ObjectTemplate> raw_template = MakeRequestTemplate();

    request_template_ = Persistent<ObjectTemplate>::New(raw_template);

  }

  Handle<ObjectTemplate> templ = request_template_;

  // Create an empty http request wrapper.

  Handle<Object> result = templ->NewInstance();

  // Wrap the raw C++ pointer in an External so it can be referenced

  // from within JavaScript.

  Handle<External> request_ptr = External::New(request);

  // Store the request pointer in the JavaScript wrapper.

  result->SetInternalField(0, request_ptr);

  // Return the result through the current handle scope.  Since each

  // of these handles will go away when the handle scope is deleted

  // we need to call Close to let one, the result, escape into the

  // outer handle scope.

  return handle_scope.Close(result);

}

/**

 * Utility function that extracts the C++ http request object from a

 * wrapper object.

 */

HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Handle<Object> obj) {

  Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));

  void* ptr = field->Value();

  return static_cast<HttpRequest*>(ptr);

}

Handle<Value> JsHttpRequestProcessor::GetPath(Local<String> name,

                                              const AccessorInfo& info) {

  // Extract the C++ request object from the JavaScript wrapper.

  HttpRequest* request = UnwrapRequest(info.Holder());

  // Fetch the path.

  const string& path = request->Path();

  // Wrap the result in a JavaScript string and return it.

  return String::New(path.c_str(), path.length());

}

Handle<Value> JsHttpRequestProcessor::GetReferrer(Local<String> name,

                                                  const AccessorInfo& info) {

  HttpRequest* request = UnwrapRequest(info.Holder());

  const string& path = request->Referrer();

  return String::New(path.c_str(), path.length());

}

Handle<Value> JsHttpRequestProcessor::GetHost(Local<String> name,

                                              const AccessorInfo& info) {

  HttpRequest* request = UnwrapRequest(info.Holder());

  const string& path = request->Host();

  return String::New(path.c_str(), path.length());

}

Handle<Value> JsHttpRequestProcessor::GetUserAgent(Local<String> name,

                                                   const AccessorInfo& info) {

  HttpRequest* request = UnwrapRequest(info.Holder());

  const string& path = request->UserAgent();

  return String::New(path.c_str(), path.length());

}

Handle<ObjectTemplate> JsHttpRequestProcessor::MakeRequestTemplate() {

  HandleScope handle_scope;

  Handle<ObjectTemplate> result = ObjectTemplate::New();

  result->SetInternalFieldCount(1);

  // Add accessors for each of the fields of the request.

  result->SetAccessor(String::NewSymbol("path"), GetPath);

  result->SetAccessor(String::NewSymbol("referrer"), GetReferrer);

  result->SetAccessor(String::NewSymbol("host"), GetHost);

  result->SetAccessor(String::NewSymbol("userAgent"), GetUserAgent);

  // Again, return the result through the current handle scope.

  return handle_scope.Close(result);

}

// --- Test ---

void HttpRequestProcessor::Log(const char* event) {

  printf("Logged: %s\n", event);

}

/**

 * A simplified http request.

 */

class StringHttpRequest : public HttpRequest {

 public:

  StringHttpRequest(const string& path,

                    const string& referrer,

                    const string& host,

                    const string& user_agent);

  virtual const string& Path() { return path_; }

  virtual const string& Referrer() { return referrer_; }

  virtual const string& Host() { return host_; }

  virtual const string& UserAgent() { return user_agent_; }

 private:

  string path_;

  string referrer_;

  string host_;

  string user_agent_;

};

StringHttpRequest::StringHttpRequest(const string& path,

                                     const string& referrer,

                                     const string& host,

                                     const string& user_agent)

    : path_(path),

      referrer_(referrer),

      host_(host),

      user_agent_(user_agent) { }

void ParseOptions(int argc,

                  char* argv[],

                  map<string, string>& options,

                  string* file) {

  for (int i = 1; i < argc; i++) {

    string arg = argv[i];

    int index = arg.find('=', 0);

    if (index == string::npos) {

      *file = arg;

    } else {

      string key = arg.substr(0, index);

      string value = arg.substr(index+1);

      options[key] = value;

    }

  }

}

// Reads a file into a v8 string.

Handle<String> ReadFile(const string& name) {

  FILE* file = fopen(name.c_str(), "rb");

  if (file == NULL) return Handle<String>();

  fseek(file, 0, SEEK_END);

  int size = ftell(file);

  rewind(file);

  char* chars = new char[size + 1];

  chars[size] = '\0';

  for (int i = 0; i < size;) {

    int read = fread(&chars[i], 1, size - i, file);

    i += read;

  }

  fclose(file);

  Handle<String> result = String::New(chars, size);

  delete[] chars;

  return result;

}

const int kSampleSize = 6;

StringHttpRequest kSampleRequests[kSampleSize] = {

  StringHttpRequest("/process.cc", "localhost", "google.com", "firefox"),

  StringHttpRequest("/", "localhost", "google.net", "firefox"),

  StringHttpRequest("/", "localhost", "google.org", "safari"),

  StringHttpRequest("/", "localhost", "yahoo.com", "ie"),

  StringHttpRequest("/", "localhost", "yahoo.com", "safari"),

  StringHttpRequest("/", "localhost", "yahoo.com", "firefox")

};

bool ProcessEntries(HttpRequestProcessor* processor, int count,

                    StringHttpRequest* reqs) {

  for (int i = 0; i < count; i++) {

    if (!processor->Process(&reqs[i]))

      return false;

  }

  return true;

}

void PrintMap(map<string, string>* m) {

  for (map<string, string>::iterator i = m->begin(); i != m->end(); i++) {

    pair<string, string> entry = *i;

    printf("%s: %s\n", entry.first.c_str(), entry.second.c_str());

  }

}

int main(int argc, char* argv[]) {

  map<string, string> options;

  string file;

  ParseOptions(argc, argv, options, &file);

  if (file.empty()) {

    fprintf(stderr, "No script was specified.\n");

    return 1;

  }

  HandleScope scope;

  Handle<String> source = ReadFile(file);

  if (source.IsEmpty()) {

    fprintf(stderr, "Error reading '%s'.\n", file.c_str());

    return 1;

  }

  JsHttpRequestProcessor processor(source);

  map<string, string> output;

  if (!processor.Initialize(&options, &output)) {

    fprintf(stderr, "Error initializing processor.\n");

    return 1;

  }

  if (!ProcessEntries(&processor, kSampleSize, kSampleRequests))

    return 1;

  PrintMap(&output);

}