proxy_resolver_v8.cc revision 0c66f82bb6180da8fd218d66e3613a2a19345ff2
1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <algorithm>
6#include <cstdio>
7#include <string>
8
9#include <utils/String16.h>
10
11#include "proxy_resolver_v8.h"
12
13#include "proxy_resolver_script.h"
14#include "net_util.h"
15#include <include/v8.h>
16#include <algorithm>
17#include <vector>
18
19#include <iostream>
20
21#include <string.h>
22#include <utils/String8.h>
23#include <utils/String16.h>
24
25// Notes on the javascript environment:
26//
27// For the majority of the PAC utility functions, we use the same code
28// as Firefox. See the javascript library that proxy_resolver_scipt.h
29// pulls in.
30//
31// In addition, we implement a subset of Microsoft's extensions to PAC.
32// - myIpAddressEx()
33// - dnsResolveEx()
34// - isResolvableEx()
35// - isInNetEx()
36// - sortIpAddressList()
37//
38// It is worth noting that the original PAC specification does not describe
39// the return values on failure. Consequently, there are compatibility
40// differences between browsers on what to return on failure, which are
41// illustrated below:
42//
43// --------------------+-------------+-------------------+--------------
44//                     | Firefox3    | InternetExplorer8 |  --> Us <---
45// --------------------+-------------+-------------------+--------------
46// myIpAddress()       | "127.0.0.1" |  ???              |  "127.0.0.1"
47// dnsResolve()        | null        |  false            |  null
48// myIpAddressEx()     | N/A         |  ""               |  ""
49// sortIpAddressList() | N/A         |  false            |  false
50// dnsResolveEx()      | N/A         |  ""               |  ""
51// isInNetEx()         | N/A         |  false            |  false
52// --------------------+-------------+-------------------+--------------
53//
54// TODO: The cell above reading ??? means I didn't test it.
55//
56// Another difference is in how dnsResolve() and myIpAddress() are
57// implemented -- whether they should restrict to IPv4 results, or
58// include both IPv4 and IPv6. The following table illustrates the
59// differences:
60//
61// --------------------+-------------+-------------------+--------------
62//                     | Firefox3    | InternetExplorer8 |  --> Us <---
63// --------------------+-------------+-------------------+--------------
64// myIpAddress()       | IPv4/IPv6   |  IPv4             |  IPv4
65// dnsResolve()        | IPv4/IPv6   |  IPv4             |  IPv4
66// isResolvable()      | IPv4/IPv6   |  IPv4             |  IPv4
67// myIpAddressEx()     | N/A         |  IPv4/IPv6        |  IPv4/IPv6
68// dnsResolveEx()      | N/A         |  IPv4/IPv6        |  IPv4/IPv6
69// sortIpAddressList() | N/A         |  IPv4/IPv6        |  IPv4/IPv6
70// isResolvableEx()    | N/A         |  IPv4/IPv6        |  IPv4/IPv6
71// isInNetEx()         | N/A         |  IPv4/IPv6        |  IPv4/IPv6
72// -----------------+-------------+-------------------+--------------
73
74static bool DoIsStringASCII(const android::String16& str) {
75  for (size_t i = 0; i < str.size(); i++) {
76    unsigned short c = str.string()[i];
77    if (c > 0x7F)
78      return false;
79  }
80  return true;
81}
82
83bool IsStringASCII(const android::String16& str) {
84  return DoIsStringASCII(str);
85}
86
87namespace net {
88
89namespace {
90
91// Pseudo-name for the PAC script.
92const char kPacResourceName[] = "proxy-pac-script.js";
93// Pseudo-name for the PAC utility script.
94const char kPacUtilityResourceName[] = "proxy-pac-utility-script.js";
95
96// External string wrapper so V8 can access the UTF16 string wrapped by
97// ProxyResolverScriptData.
98class V8ExternalStringFromScriptData
99    : public v8::String::ExternalStringResource {
100 public:
101  explicit V8ExternalStringFromScriptData(
102      const android::String16& script_data)
103      : script_data_(script_data) {}
104
105  virtual const uint16_t* data() const {
106    return script_data_.string();
107  }
108
109  virtual size_t length() const {
110    return script_data_.size();
111  }
112
113 private:
114  const android::String16& script_data_;
115//  DISALLOW_COPY_AND_ASSIGN(V8ExternalStringFromScriptData);
116};
117
118// External string wrapper so V8 can access a string literal.
119class V8ExternalASCIILiteral : public v8::String::ExternalAsciiStringResource {
120 public:
121  // |ascii| must be a NULL-terminated C string, and must remain valid
122  // throughout this object's lifetime.
123  V8ExternalASCIILiteral(const char* ascii, size_t length)
124      : ascii_(ascii), length_(length) {
125  }
126
127  virtual const char* data() const {
128    return ascii_;
129  }
130
131  virtual size_t length() const {
132    return length_;
133  }
134
135 private:
136  const char* ascii_;
137  size_t length_;
138};
139
140// When creating a v8::String from a C++ string we have two choices: create
141// a copy, or create a wrapper that shares the same underlying storage.
142// For small strings it is better to just make a copy, whereas for large
143// strings there are savings by sharing the storage. This number identifies
144// the cutoff length for when to start wrapping rather than creating copies.
145const size_t kMaxStringBytesForCopy = 256;
146
147template <class string_type>
148inline typename string_type::value_type* WriteInto(string_type* str,
149                                                   size_t length_with_null) {
150  str->reserve(length_with_null);
151  str->resize(length_with_null - 1);
152  return &((*str)[0]);
153}
154
155// Converts a V8 String to a UTF8 std::string.
156std::string V8StringToUTF8(v8::Handle<v8::String> s) {
157  std::string result;
158  s->WriteUtf8(WriteInto(&result, s->Length() + 1));
159  return result;
160}
161
162// Converts a V8 String to a UTF16 string.
163android::String16 V8StringToUTF16(v8::Handle<v8::String> s) {
164  int len = s->Length();
165  char16_t* buf = new char16_t[len + 1];
166  s->Write(buf, 0, len);
167  android::String16 ret(buf, len);
168  delete buf;
169  return ret;
170}
171
172std::string UTF16ToASCII(const android::String16& str) {
173    android::String8 rstr(str);
174    return std::string(rstr.string());
175}
176
177android::String16 ASCIIToUTF16(const std::string str) {
178  android::String8 str8(str.c_str());
179  return android::String16(str8);
180}
181
182// Converts an ASCII std::string to a V8 string.
183v8::Local<v8::String> ASCIIStringToV8String(const std::string& s) {
184  return v8::String::New(s.data(), s.size());
185}
186
187v8::Local<v8::String> UTF16StringToV8String(const android::String16& s) {
188  return v8::String::New(s.string(), s.size());
189}
190
191// Converts an ASCII string literal to a V8 string.
192v8::Local<v8::String> ASCIILiteralToV8String(const char* ascii) {
193//  DCHECK(IsStringASCII(ascii));
194  size_t length = strlen(ascii);
195  if (length <= kMaxStringBytesForCopy)
196    return v8::String::New(ascii, length);
197  return v8::String::NewExternal(new V8ExternalASCIILiteral(ascii, length));
198}
199
200// Stringizes a V8 object by calling its toString() method. Returns true
201// on success. This may fail if the toString() throws an exception.
202bool V8ObjectToUTF16String(v8::Handle<v8::Value> object,
203                           android::String16* utf16_result) {
204  if (object.IsEmpty())
205    return false;
206
207  v8::HandleScope scope;
208  v8::Local<v8::String> str_object = object->ToString();
209  if (str_object.IsEmpty())
210    return false;
211  *utf16_result = V8StringToUTF16(str_object);
212  return true;
213}
214
215// Extracts an hostname argument from |args|. On success returns true
216// and fills |*hostname| with the result.
217bool GetHostnameArgument(const v8::Arguments& args, std::string* hostname) {
218  // The first argument should be a string.
219  if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
220    return false;
221
222  const android::String16 hostname_utf16 = V8StringToUTF16(args[0]->ToString());
223
224  // If the hostname is already in ASCII, simply return it as is.
225  if (IsStringASCII(hostname_utf16)) {
226    *hostname = UTF16ToASCII(hostname_utf16);
227    return true;
228  }
229  return false;
230}
231
232// Wrapper for passing around IP address strings and IPAddressNumber objects.
233struct IPAddress {
234  IPAddress(const std::string& ip_string, const IPAddressNumber& ip_number)
235      : string_value(ip_string),
236        ip_address_number(ip_number) {
237  }
238
239  // Used for sorting IP addresses in ascending order in SortIpAddressList().
240  // IP6 addresses are placed ahead of IPv4 addresses.
241  bool operator<(const IPAddress& rhs) const {
242    const IPAddressNumber& ip1 = this->ip_address_number;
243    const IPAddressNumber& ip2 = rhs.ip_address_number;
244    if (ip1.size() != ip2.size())
245      return ip1.size() > ip2.size();  // IPv6 before IPv4.
246    return memcmp(&ip1[0], &ip2[0], ip1.size()) < 0;  // Ascending order.
247  }
248
249  std::string string_value;
250  IPAddressNumber ip_address_number;
251};
252
253template<typename STR>
254bool RemoveCharsT(const STR& input,
255                  const typename STR::value_type remove_chars[],
256                  STR* output) {
257  bool removed = false;
258  size_t found;
259
260  *output = input;
261
262  found = output->find_first_of(remove_chars);
263  while (found != STR::npos) {
264    removed = true;
265    output->replace(found, 1, STR());
266    found = output->find_first_of(remove_chars, found);
267  }
268
269  return removed;
270}
271
272bool RemoveChars(const std::string& input,
273                 const char remove_chars[],
274                 std::string* output) {
275  return RemoveCharsT(input, remove_chars, output);
276}
277
278// Handler for "sortIpAddressList(IpAddressList)". |ip_address_list| is a
279// semi-colon delimited string containing IP addresses.
280// |sorted_ip_address_list| is the resulting list of sorted semi-colon delimited
281// IP addresses or an empty string if unable to sort the IP address list.
282// Returns 'true' if the sorting was successful, and 'false' if the input was an
283// empty string, a string of separators (";" in this case), or if any of the IP
284// addresses in the input list failed to parse.
285bool SortIpAddressList(const std::string& ip_address_list,
286                       std::string* sorted_ip_address_list) {
287  sorted_ip_address_list->clear();
288
289  // Strip all whitespace (mimics IE behavior).
290  std::string cleaned_ip_address_list;
291  RemoveChars(ip_address_list, " \t", &cleaned_ip_address_list);
292  if (cleaned_ip_address_list.empty())
293    return false;
294
295  // Split-up IP addresses and store them in a vector.
296  std::vector<IPAddress> ip_vector;
297  IPAddressNumber ip_num;
298  char *tok_list = strtok((char *)cleaned_ip_address_list.c_str(), ";");
299  while (tok_list != NULL) {
300    if (!ParseIPLiteralToNumber(tok_list, &ip_num))
301      return false;
302    ip_vector.push_back(IPAddress(tok_list, ip_num));
303    tok_list = strtok(NULL, ";");
304  }
305
306  if (ip_vector.empty())  // Can happen if we have something like
307    return false;         // sortIpAddressList(";") or sortIpAddressList("; ;")
308
309  // Sort lists according to ascending numeric value.
310  if (ip_vector.size() > 1)
311    std::stable_sort(ip_vector.begin(), ip_vector.end());
312
313  // Return a semi-colon delimited list of sorted addresses (IPv6 followed by
314  // IPv4).
315  for (size_t i = 0; i < ip_vector.size(); ++i) {
316    if (i > 0)
317      *sorted_ip_address_list += ";";
318    *sorted_ip_address_list += ip_vector[i].string_value;
319  }
320  return true;
321}
322
323
324// Handler for "isInNetEx(ip_address, ip_prefix)". |ip_address| is a string
325// containing an IPv4/IPv6 address, and |ip_prefix| is a string containg a
326// slash-delimited IP prefix with the top 'n' bits specified in the bit
327// field. This returns 'true' if the address is in the same subnet, and
328// 'false' otherwise. Also returns 'false' if the prefix is in an incorrect
329// format, or if an address and prefix of different types are used (e.g. IPv6
330// address and IPv4 prefix).
331bool IsInNetEx(const std::string& ip_address, const std::string& ip_prefix) {
332  IPAddressNumber address;
333  std::string cleaned_ip_address;
334  if (RemoveChars(ip_address, " \t", &cleaned_ip_address))
335    return false;
336  if (!ParseIPLiteralToNumber(ip_address, &address))
337    return false;
338
339  IPAddressNumber prefix;
340  size_t prefix_length_in_bits;
341  if (!ParseCIDRBlock(ip_prefix, &prefix, &prefix_length_in_bits))
342    return false;
343
344  // Both |address| and |prefix| must be of the same type (IPv4 or IPv6).
345  if (address.size() != prefix.size())
346    return false;
347
348  return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
349}
350
351}  // namespace
352
353// ProxyResolverV8::Context ---------------------------------------------------
354
355class ProxyResolverV8::Context {
356 public:
357  explicit Context(ProxyResolverJSBindings* js_bindings,
358          ProxyErrorListener* error_listener)
359      : js_bindings_(js_bindings), error_listener_(error_listener) {
360  }
361
362  ~Context() {
363    v8::Locker locked;
364
365    v8_this_.Dispose();
366    v8_context_.Dispose();
367
368    // Run the V8 garbage collector. We do this to be sure the
369    // ExternalStringResource objects we allocated get properly disposed.
370    // Otherwise when running the unit-tests they may get leaked.
371    // See crbug.com/48145.
372    PurgeMemory();
373  }
374
375  int ResolveProxy(const android::String16 url, const android::String16 host, android::String16* results) {
376    v8::Locker locked;
377    v8::HandleScope scope;
378
379    v8::Context::Scope function_scope(v8_context_);
380
381    v8::Local<v8::Value> function;
382    if (!GetFindProxyForURL(&function)) {
383      *results = ASCIIToUTF16("FindProxyForURL() is undefined");
384      return ERR_PAC_SCRIPT_FAILED;
385    }
386
387    v8::Handle<v8::Value> argv[] = {
388        UTF16StringToV8String(url),
389        UTF16StringToV8String(host) };
390
391    v8::TryCatch try_catch;
392    v8::Local<v8::Value> ret = v8::Function::Cast(*function)->Call(
393        v8_context_->Global(), 2, argv);
394
395    if (try_catch.HasCaught()) {
396      *results = V8StringToUTF16(try_catch.Message()->Get());
397      return ERR_PAC_SCRIPT_FAILED;
398    }
399
400    if (!ret->IsString()) {
401      *results = ASCIIToUTF16("FindProxyForURL() did not return a string.");
402      return ERR_PAC_SCRIPT_FAILED;
403    }
404
405    *results = V8StringToUTF16(ret->ToString());
406
407    if (!IsStringASCII(*results)) {
408      // TODO:         Rather than failing when a wide string is returned, we
409      //               could extend the parsing to handle IDNA hostnames by
410      //               converting them to ASCII punycode.
411      //               crbug.com/47234
412      *results = ASCIIToUTF16("FindProxyForURL() returned a non-ASCII string");
413      return ERR_PAC_SCRIPT_FAILED;
414    }
415
416    return OK;
417  }
418
419  int InitV8(const android::String16& pac_script) {
420    v8::Locker locked;
421    v8::HandleScope scope;
422
423    v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
424    v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
425
426    // Attach the javascript bindings.
427    v8::Local<v8::FunctionTemplate> alert_template =
428        v8::FunctionTemplate::New(&AlertCallback, v8_this_);
429    global_template->Set(ASCIILiteralToV8String("alert"), alert_template);
430
431    v8::Local<v8::FunctionTemplate> my_ip_address_template =
432        v8::FunctionTemplate::New(&MyIpAddressCallback, v8_this_);
433    global_template->Set(ASCIILiteralToV8String("myIpAddress"),
434        my_ip_address_template);
435
436    v8::Local<v8::FunctionTemplate> dns_resolve_template =
437        v8::FunctionTemplate::New(&DnsResolveCallback, v8_this_);
438    global_template->Set(ASCIILiteralToV8String("dnsResolve"),
439        dns_resolve_template);
440
441    // Microsoft's PAC extensions:
442
443    v8::Local<v8::FunctionTemplate> dns_resolve_ex_template =
444        v8::FunctionTemplate::New(&DnsResolveExCallback, v8_this_);
445    global_template->Set(ASCIILiteralToV8String("dnsResolveEx"),
446                         dns_resolve_ex_template);
447
448    v8::Local<v8::FunctionTemplate> my_ip_address_ex_template =
449        v8::FunctionTemplate::New(&MyIpAddressExCallback, v8_this_);
450    global_template->Set(ASCIILiteralToV8String("myIpAddressEx"),
451                         my_ip_address_ex_template);
452
453    v8::Local<v8::FunctionTemplate> sort_ip_address_list_template =
454        v8::FunctionTemplate::New(&SortIpAddressListCallback, v8_this_);
455    global_template->Set(ASCIILiteralToV8String("sortIpAddressList"),
456                         sort_ip_address_list_template);
457
458    v8::Local<v8::FunctionTemplate> is_in_net_ex_template =
459        v8::FunctionTemplate::New(&IsInNetExCallback, v8_this_);
460    global_template->Set(ASCIILiteralToV8String("isInNetEx"),
461                         is_in_net_ex_template);
462
463    v8_context_ = v8::Context::New(NULL, global_template);
464
465    v8::Context::Scope ctx(v8_context_);
466
467    // Add the PAC utility functions to the environment.
468    // (This script should never fail, as it is a string literal!)
469    // Note that the two string literals are concatenated.
470    int rv = RunScript(
471        ASCIILiteralToV8String(
472            PROXY_RESOLVER_SCRIPT
473            PROXY_RESOLVER_SCRIPT_EX),
474        kPacUtilityResourceName);
475    if (rv != OK) {
476      return rv;
477    }
478
479    // Add the user's PAC code to the environment.
480    rv = RunScript(UTF16StringToV8String(pac_script), kPacResourceName);
481    if (rv != OK) {
482      return rv;
483    }
484
485    // At a minimum, the FindProxyForURL() function must be defined for this
486    // to be a legitimiate PAC script.
487    v8::Local<v8::Value> function;
488    if (!GetFindProxyForURL(&function))
489      return ERR_PAC_SCRIPT_FAILED;
490
491    return OK;
492  }
493
494  void PurgeMemory() {
495    v8::Locker locked;
496    // Repeatedly call the V8 idle notification until it returns true ("nothing
497    // more to free").  Note that it makes more sense to do this than to
498    // implement a new "delete everything" pass because object references make
499    // it difficult to free everything possible in just one pass.
500    while (!v8::V8::IdleNotification())
501      ;
502  }
503
504 private:
505  bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
506    *function = v8_context_->Global()->Get(
507        ASCIILiteralToV8String("FindProxyForURL"));
508    return (*function)->IsFunction();
509  }
510
511  // Handle an exception thrown by V8.
512  void HandleError(v8::Handle<v8::Message> message) {
513    if (message.IsEmpty())
514      return;
515    error_listener_->ErrorMessage(V8StringToUTF16(message->Get()));
516  }
517
518  // Compiles and runs |script| in the current V8 context.
519  // Returns OK on success, otherwise an error code.
520  int RunScript(v8::Handle<v8::String> script, const char* script_name) {
521    v8::TryCatch try_catch;
522
523    // Compile the script.
524    v8::ScriptOrigin origin =
525        v8::ScriptOrigin(ASCIILiteralToV8String(script_name));
526    v8::Local<v8::Script> code = v8::Script::Compile(script, &origin);
527
528    // Execute.
529    if (!code.IsEmpty())
530      code->Run();
531
532    // Check for errors.
533    if (try_catch.HasCaught()) {
534      HandleError(try_catch.Message());
535      return ERR_PAC_SCRIPT_FAILED;
536    }
537
538    return OK;
539  }
540
541  // V8 callback for when "alert()" is invoked by the PAC script.
542  static v8::Handle<v8::Value> AlertCallback(const v8::Arguments& args) {
543    Context* context =
544        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
545
546    // Like firefox we assume "undefined" if no argument was specified, and
547    // disregard any arguments beyond the first.
548    android::String16 message;
549    if (args.Length() == 0) {
550      std::string undef = "undefined";
551      android::String8 undef8(undef.c_str());
552      android::String16 wundef(undef8);
553      message = wundef;
554    } else {
555      if (!V8ObjectToUTF16String(args[0], &message))
556        return v8::Undefined();  // toString() threw an exception.
557    }
558
559    context->error_listener_->AlertMessage(message);
560    return v8::Undefined();
561  }
562
563  // V8 callback for when "myIpAddress()" is invoked by the PAC script.
564  static v8::Handle<v8::Value> MyIpAddressCallback(const v8::Arguments& args) {
565    Context* context =
566        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
567
568    std::string result;
569    bool success;
570
571    {
572      v8::Unlocker unlocker;
573
574      // We shouldn't be called with any arguments, but will not complain if
575      // we are.
576      success = context->js_bindings_->MyIpAddress(&result);
577    }
578
579    if (!success)
580      return ASCIILiteralToV8String("127.0.0.1");
581    return ASCIIStringToV8String(result);
582  }
583
584  // V8 callback for when "myIpAddressEx()" is invoked by the PAC script.
585  static v8::Handle<v8::Value> MyIpAddressExCallback(
586      const v8::Arguments& args) {
587    Context* context =
588        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
589
590    std::string ip_address_list;
591    bool success;
592
593    {
594      v8::Unlocker unlocker;
595
596      // We shouldn't be called with any arguments, but will not complain if
597      // we are.
598      success = context->js_bindings_->MyIpAddressEx(&ip_address_list);
599    }
600
601    if (!success)
602      ip_address_list = std::string();
603    return ASCIIStringToV8String(ip_address_list);
604  }
605
606  // V8 callback for when "dnsResolve()" is invoked by the PAC script.
607  static v8::Handle<v8::Value> DnsResolveCallback(const v8::Arguments& args) {
608    Context* context =
609        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
610
611    // We need at least one string argument.
612    std::string hostname;
613    if (!GetHostnameArgument(args, &hostname))
614      return v8::Null();
615
616    std::string ip_address;
617    bool success;
618
619    {
620      v8::Unlocker unlocker;
621      success = context->js_bindings_->DnsResolve(hostname, &ip_address);
622    }
623
624    return success ? ASCIIStringToV8String(ip_address) : v8::Null();
625  }
626
627  // V8 callback for when "dnsResolveEx()" is invoked by the PAC script.
628  static v8::Handle<v8::Value> DnsResolveExCallback(const v8::Arguments& args) {
629    Context* context =
630        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
631
632    // We need at least one string argument.
633    std::string hostname;
634    if (!GetHostnameArgument(args, &hostname))
635      return v8::Undefined();
636
637    std::string ip_address_list;
638    bool success;
639
640    {
641      v8::Unlocker unlocker;
642      success = context->js_bindings_->DnsResolveEx(hostname, &ip_address_list);
643    }
644
645    if (!success)
646      ip_address_list = std::string();
647
648    return ASCIIStringToV8String(ip_address_list);
649  }
650
651  // V8 callback for when "sortIpAddressList()" is invoked by the PAC script.
652  static v8::Handle<v8::Value> SortIpAddressListCallback(
653      const v8::Arguments& args) {
654    // We need at least one string argument.
655    if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
656      return v8::Null();
657
658    std::string ip_address_list = V8StringToUTF8(args[0]->ToString());
659    std::string sorted_ip_address_list;
660    bool success = SortIpAddressList(ip_address_list, &sorted_ip_address_list);
661    if (!success)
662      return v8::False();
663    return ASCIIStringToV8String(sorted_ip_address_list);
664  }
665
666  // V8 callback for when "isInNetEx()" is invoked by the PAC script.
667  static v8::Handle<v8::Value> IsInNetExCallback(const v8::Arguments& args) {
668    // We need at least 2 string arguments.
669    if (args.Length() < 2 || args[0].IsEmpty() || !args[0]->IsString() ||
670        args[1].IsEmpty() || !args[1]->IsString())
671      return v8::Null();
672
673    std::string ip_address = V8StringToUTF8(args[0]->ToString());
674    std::string ip_prefix = V8StringToUTF8(args[1]->ToString());
675    return IsInNetEx(ip_address, ip_prefix) ? v8::True() : v8::False();
676  }
677
678  ProxyResolverJSBindings* js_bindings_;
679  ProxyErrorListener* error_listener_;
680  v8::Persistent<v8::External> v8_this_;
681  v8::Persistent<v8::Context> v8_context_;
682};
683
684// ProxyResolverV8 ------------------------------------------------------------
685
686ProxyResolverV8::ProxyResolverV8(
687    ProxyResolverJSBindings* custom_js_bindings,
688    ProxyErrorListener* error_listener)
689    : context_(NULL), js_bindings_(custom_js_bindings),
690      error_listener_(error_listener) {
691
692}
693
694ProxyResolverV8::~ProxyResolverV8() {
695  if (context_ != NULL) {
696    delete context_;
697    context_ = NULL;
698  }
699  if (js_bindings_ != NULL) {
700    delete js_bindings_;
701  }
702}
703
704int ProxyResolverV8::GetProxyForURL(const android::String16 spec, const android::String16 host,
705                                    android::String16* results) {
706  // If the V8 instance has not been initialized (either because
707  // SetPacScript() wasn't called yet, or because it failed.
708  if (context_ == NULL)
709    return ERR_FAILED;
710
711  // Otherwise call into V8.
712  int rv = context_->ResolveProxy(spec, host, results);
713
714  return rv;
715}
716
717void ProxyResolverV8::PurgeMemory() {
718  context_->PurgeMemory();
719}
720
721int ProxyResolverV8::SetPacScript(android::String16& script_data) {
722  if (context_ != NULL) {
723    delete context_;
724    context_ = NULL;
725  }
726  if (script_data.size() == 0)
727    return ERR_PAC_SCRIPT_FAILED;
728
729  // Try parsing the PAC script.
730  context_ = new Context(js_bindings_, error_listener_);
731  int rv;
732  if ((rv = context_->InitV8(script_data)) != OK) {
733    context_ = NULL;
734  }
735  if (rv != OK)
736    context_ = NULL;
737  return rv;
738}
739
740}  // namespace net
741