rev 11020 : 8201563: Update copyright header for files modified in 2018
Reviewed-by:

   1 /*
   2  * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 #include "config.h"
   5 
   6 #if COMPILER(GCC)
   7 #pragma GCC diagnostic ignored "-Wunused-parameter"
   8 #endif
   9 
  10 #include "URLLoader.h"
  11 #include "FrameNetworkingContextJava.h"
  12 #include "HTTPParsers.h"
  13 #include <wtf/CompletionHandler.h>
  14 #include <wtf/java/JavaEnv.h>
  15 #include "MIMETypeRegistry.h"
  16 #include "ResourceError.h"
  17 #include "ResourceHandle.h"
  18 #include "ResourceRequest.h"
  19 #include "ResourceResponse.h"
  20 #include "ResourceHandleClient.h"
  21 #include "WebPage.h"
  22 #include "com_sun_webkit_LoadListenerClient.h"
  23 #include "com_sun_webkit_network_URLLoader.h"
  24 
  25 namespace WebCore {
  26 class Page;
  27 }
  28 
  29 namespace WebCore {
  30 
  31 namespace URLLoaderJavaInternal {
  32 
  33 static JGClass networkContextClass;
  34 static jmethodID loadMethod;
  35 
  36 static JGClass urlLoaderClass;
  37 static jmethodID cancelMethod;
  38 
  39 static JGClass formDataElementClass;
  40 static jmethodID createFromFileMethod;
  41 static jmethodID createFromByteArrayMethod;
  42 
  43 static void initRefs(JNIEnv* env)
  44 {
  45     if (!networkContextClass) {
  46         networkContextClass = JLClass(env->FindClass(
  47                 "com/sun/webkit/network/NetworkContext"));
  48         ASSERT(networkContextClass);
  49 
  50         loadMethod = env->GetStaticMethodID(
  51                 networkContextClass,
  52                 "fwkLoad",
  53                 "(Lcom/sun/webkit/WebPage;Z"
  54                 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;"
  55                 "[Lcom/sun/webkit/network/FormDataElement;J)"
  56                 "Lcom/sun/webkit/network/URLLoader;");
  57         ASSERT(loadMethod);
  58     }
  59     if (!urlLoaderClass) {
  60         urlLoaderClass = JLClass(env->FindClass(
  61                 "com/sun/webkit/network/URLLoader"));
  62         ASSERT(urlLoaderClass);
  63 
  64         cancelMethod = env->GetMethodID(urlLoaderClass, "fwkCancel", "()V");
  65         ASSERT(cancelMethod);
  66     }
  67     if (!formDataElementClass) {
  68         formDataElementClass = JLClass(env->FindClass(
  69                 "com/sun/webkit/network/FormDataElement"));
  70         ASSERT(formDataElementClass);
  71 
  72         createFromByteArrayMethod = env->GetStaticMethodID(
  73                 formDataElementClass,
  74                 "fwkCreateFromByteArray",
  75                 "([B)Lcom/sun/webkit/network/FormDataElement;");
  76         ASSERT(createFromByteArrayMethod);
  77 
  78         createFromFileMethod = env->GetStaticMethodID(
  79                 formDataElementClass,
  80                 "fwkCreateFromFile",
  81                 "(Ljava/lang/String;)"
  82                 "Lcom/sun/webkit/network/FormDataElement;");
  83         ASSERT(createFromFileMethod);
  84     }
  85 }
  86 
  87 static bool shouldRedirectAsGET(const ResourceRequest& request, const ResourceResponse& response, bool crossOrigin)
  88 {
  89     if (request.httpMethod() == "GET" || request.httpMethod() == "HEAD")
  90         return false;
  91 
  92     if (!request.url().protocolIsInHTTPFamily())
  93         return true;
  94 
  95     if (response.isSeeOther())
  96         return true;
  97 
  98     if ((response.isMovedPermanently() || response.isFound()) && (request.httpMethod() == "POST"))
  99         return true;
 100 
 101     if (crossOrigin && (request.httpMethod() == "DELETE"))
 102         return true;
 103 
 104     return false;
 105 }
 106 }
 107 
 108 URLLoader::URLLoader()
 109 {
 110 }
 111 
 112 URLLoader::~URLLoader()
 113 {
 114     cancel();
 115 }
 116 
 117 std::unique_ptr<URLLoader> URLLoader::loadAsynchronously(NetworkingContext* context,
 118                                                     ResourceHandle* handle)
 119 {
 120     std::unique_ptr<URLLoader> result = std::unique_ptr<URLLoader>(new URLLoader());
 121     result->m_target = std::unique_ptr<AsynchronousTarget>(new AsynchronousTarget(handle));
 122     result->m_ref = load(
 123             true,
 124             context,
 125             handle->firstRequest(),
 126             result->m_target.get());
 127     return result;
 128 }
 129 
 130 void URLLoader::cancel()
 131 {
 132     using namespace URLLoaderJavaInternal;
 133     if (m_ref) {
 134         JNIEnv* env = WebCore_GetJavaEnv();
 135         initRefs(env);
 136 
 137         env->CallVoidMethod(m_ref, cancelMethod);
 138         CheckAndClearException(env);
 139 
 140         m_ref.clear();
 141     }
 142 }
 143 
 144 void URLLoader::loadSynchronously(NetworkingContext* context,
 145                                   const ResourceRequest& request,
 146                                   ResourceError& error,
 147                                   ResourceResponse& response,
 148                                   Vector<char>& data)
 149 {
 150     SynchronousTarget target(request, error, response, data);
 151     load(false, context, request, &target);
 152 }
 153 
 154 JLObject URLLoader::load(bool asynchronous,
 155                          NetworkingContext* context,
 156                          const ResourceRequest& request,
 157                          Target* target)
 158 {
 159     using namespace URLLoaderJavaInternal;
 160     if (!context) {
 161         return nullptr;
 162     }
 163 
 164     if (!context->isValid()) {
 165         // If NetworkingContext is invalid then we are no longer attached
 166         // to a Page. This must be an attempt to load from an unload handler,
 167         // so let's just block it.
 168         return nullptr;
 169     }
 170 
 171     Page* page = static_cast<FrameNetworkingContextJava*>(context)->page();
 172     ASSERT(page);
 173 
 174     JLObject webPage = WebPage::jobjectFromPage(page);
 175     ASSERT(webPage);
 176 
 177     String headerString;
 178     const HTTPHeaderMap& headerMap = request.httpHeaderFields();
 179     for (
 180         HTTPHeaderMap::const_iterator it = headerMap.begin();
 181         headerMap.end() != it;
 182         ++it)
 183     {
 184         headerString.append(it->key);
 185         headerString.append(": ");
 186         headerString.append(it->value);
 187         headerString.append("\n");
 188     }
 189 
 190     JNIEnv* env = WebCore_GetJavaEnv();
 191     initRefs(env);
 192 
 193     JLObject loader = env->CallStaticObjectMethod(
 194             networkContextClass,
 195             loadMethod,
 196             (jobject) webPage,
 197             bool_to_jbool(asynchronous),
 198             (jstring) request.url().string().toJavaString(env),
 199             (jstring) request.httpMethod().toJavaString(env),
 200             (jstring) headerString.toJavaString(env),
 201             (jobjectArray) toJava(request.httpBody()),
 202             ptr_to_jlong(target));
 203     CheckAndClearException(env);
 204 
 205     return loader;
 206 }
 207 
 208 JLObjectArray URLLoader::toJava(const FormData* formData)
 209 {
 210     using namespace URLLoaderJavaInternal;
 211     if (!formData) {
 212         return nullptr;
 213     }
 214 
 215     const Vector<FormDataElement>& elements = formData->elements();
 216     size_t size = elements.size();
 217     if (size == 0) {
 218         return nullptr;
 219     }
 220 
 221     JNIEnv* env = WebCore_GetJavaEnv();
 222     initRefs(env);
 223 
 224     JLObjectArray result = env->NewObjectArray(
 225             size,
 226             formDataElementClass,
 227             nullptr);
 228     for (size_t i = 0; i < size; i++) {
 229         JLObject resultElement;
 230         if (elements[i].m_type == FormDataElement::Type::EncodedFile) {
 231             resultElement = env->CallStaticObjectMethod(
 232                     formDataElementClass,
 233                     createFromFileMethod,
 234                     (jstring) elements[i].m_filename.toJavaString(env));
 235         } else {
 236             const Vector<char>& data = elements[i].m_data;
 237             JLByteArray byteArray = env->NewByteArray(data.size());
 238             env->SetByteArrayRegion(
 239                     (jbyteArray) byteArray,
 240                     (jsize) 0,
 241                     (jsize) data.size(),
 242                     (const jbyte*) data.data());
 243             resultElement = env->CallStaticObjectMethod(
 244                     formDataElementClass,
 245                     createFromByteArrayMethod,
 246                     (jbyteArray) byteArray);
 247         }
 248         env->SetObjectArrayElement(
 249                 (jobjectArray) result,
 250                 i,
 251                 (jobject) resultElement);
 252     }
 253 
 254     return result;
 255 }
 256 
 257 URLLoader::Target::~Target()
 258 {
 259 }
 260 
 261 URLLoader::AsynchronousTarget::AsynchronousTarget(ResourceHandle* handle)
 262     : m_handle(handle)
 263 {
 264 }
 265 
 266 void URLLoader::AsynchronousTarget::didSendData(long totalBytesSent,
 267                                                 long totalBytesToBeSent)
 268 {
 269     ResourceHandleClient* client = m_handle->client();
 270     if (client) {
 271         client->didSendData(m_handle, totalBytesSent, totalBytesToBeSent);
 272     }
 273 }
 274 
 275 
 276 bool URLLoader::AsynchronousTarget::willSendRequest(
 277         const String& newUrl,
 278         const String& newMethod,
 279         const ResourceResponse& response)
 280 {
 281     using namespace URLLoaderJavaInternal;
 282     ASSERT(isMainThread());
 283     ResourceHandleClient* client = m_handle->client();
 284     if (client) {
 285         ResourceRequest request = m_handle->firstRequest();
 286         String location = response.httpHeaderField(HTTPHeaderName::Location);
 287         URL newURL = URL(URL(), newUrl);
 288         bool crossOrigin = !protocolHostAndPortAreEqual(request.url(), newURL);
 289 
 290         ResourceRequest newRequest = request;
 291         newRequest.setURL(newURL);
 292 
 293         if (shouldRedirectAsGET(newRequest, response, crossOrigin)) {
 294             newRequest.setHTTPMethod("GET");
 295             newRequest.setHTTPBody(nullptr);
 296             newRequest.clearHTTPContentType();
 297         } else {
 298             newRequest.setHTTPMethod(newMethod);
 299         }
 300 
 301         // Should not set Referer after a redirect from a secure resource to non-secure one.
 302         if (!newURL.protocolIs("https") && protocolIs(newRequest.httpReferrer(), "https") && m_handle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
 303             newRequest.clearHTTPReferrer();
 304 
 305         client->willSendRequestAsync(m_handle, WTFMove(newRequest), ResourceResponse(response), [] (ResourceRequest&&) {
 306         });
 307     }
 308     return true;
 309 }
 310 
 311 void URLLoader::AsynchronousTarget::didReceiveResponse(
 312         const ResourceResponse& response)
 313 {
 314     ResourceHandleClient* client = m_handle->client();
 315     if (client) {
 316         client->didReceiveResponseAsync(m_handle, ResourceResponse(response), [] () {
 317         });
 318     }
 319 }
 320 
 321 void URLLoader::AsynchronousTarget::didReceiveData(const char* data, int length)
 322 {
 323     ResourceHandleClient* client = m_handle->client();
 324     if (client) {
 325         client->didReceiveData(m_handle, data, length, 0);
 326     }
 327 }
 328 
 329 void URLLoader::AsynchronousTarget::didFinishLoading()
 330 {
 331     ResourceHandleClient* client = m_handle->client();
 332     if (client) {
 333         client->didFinishLoading(m_handle);
 334     }
 335 }
 336 
 337 void URLLoader::AsynchronousTarget::didFail(const ResourceError& error)
 338 {
 339     ResourceHandleClient* client = m_handle->client();
 340     if (client) {
 341         client->didFail(m_handle, error);
 342     }
 343 }
 344 
 345 URLLoader::SynchronousTarget::SynchronousTarget(const ResourceRequest& request,
 346                                                 ResourceError& error,
 347                                                 ResourceResponse& response,
 348                                                 Vector<char>& data)
 349     : m_request(request)
 350     , m_error(error)
 351     , m_response(response)
 352     , m_data(data)
 353 {
 354     m_error = ResourceError();
 355 }
 356 
 357 void URLLoader::SynchronousTarget::didSendData(long, long)
 358 {
 359 }
 360 
 361 bool URLLoader::SynchronousTarget::willSendRequest(
 362         const String& newUrl,
 363         const String&,
 364         const ResourceResponse&)
 365 {
 366     // The following code was adapted from the Windows port
 367     // FIXME: This needs to be fixed to follow redirects correctly even
 368     // for cross-domain requests
 369     if (!protocolHostAndPortAreEqual(m_request.url(), URL(URL(), newUrl))) {
 370         didFail(ResourceError(
 371                 String(),
 372                 com_sun_webkit_LoadListenerClient_INVALID_RESPONSE,
 373                 m_request.url(),
 374                 "Illegal redirect"));
 375         return false;
 376     }
 377     return true;
 378 }
 379 
 380 void URLLoader::SynchronousTarget::didReceiveResponse(
 381         const ResourceResponse& response)
 382 {
 383     m_response = response;
 384 }
 385 
 386 void URLLoader::SynchronousTarget::didReceiveData(const char* data, int length)
 387 {
 388     m_data.append(data, length);
 389 }
 390 
 391 void URLLoader::SynchronousTarget::didFinishLoading()
 392 {
 393 }
 394 
 395 void URLLoader::SynchronousTarget::didFail(const ResourceError& error)
 396 {
 397     m_error = error;
 398     m_response.setHTTPStatusCode(404);
 399 }
 400 
 401 } // namespace WebCore
 402 
 403 using namespace WebCore;
 404 
 405 #ifdef __cplusplus
 406 extern "C" {
 407 #endif
 408 
 409 static void setupResponse(ResourceResponse& response,
 410                           JNIEnv* env,
 411                           jint status,
 412                           jstring contentType,
 413                           jstring contentEncoding,
 414                           jlong contentLength,
 415                           jstring headers,
 416                           jstring url)
 417 {
 418     if (status > 0) {
 419         response.setHTTPStatusCode(status);
 420     }
 421 
 422     // Fix for RT-13802: If the mime type is not specified
 423     // and the expected content length is 0 or not specified,
 424     // set the mime type to "text/html" as e.g. the CF port
 425     // does
 426     String contentTypeString(env, contentType);
 427     if (contentTypeString.isEmpty() && contentLength <= 0) {
 428         contentTypeString = "text/html";
 429     }
 430     if (!contentTypeString.isEmpty()) {
 431         response.setMimeType(
 432                 extractMIMETypeFromMediaType(contentTypeString).convertToLowercaseWithoutLocale());
 433     }
 434 
 435     String contentEncodingString(env, contentEncoding);
 436     if (contentEncodingString.isEmpty() && !contentTypeString.isEmpty()) {
 437         contentEncodingString = extractCharsetFromMediaType(contentTypeString);
 438     }
 439     if (!contentEncodingString.isEmpty()) {
 440         response.setTextEncodingName(contentEncodingString);
 441     }
 442 
 443     if (contentLength > 0) {
 444         response.setExpectedContentLength(
 445                 static_cast<long long>(contentLength));
 446     }
 447 
 448     String headersString(env, headers);
 449     int splitPos = headersString.find("\n");
 450     while (splitPos != -1) {
 451         String s = headersString.left(splitPos);
 452         int j = s.find(":");
 453         if (j != -1) {
 454             String key = s.left(j);
 455             String val = s.substring(j + 1);
 456             response.setHTTPHeaderField(key, val);
 457         }
 458         headersString = headersString.substring(splitPos + 1);
 459         splitPos = headersString.find("\n");
 460     }
 461 
 462     URL kurl = URL(URL(), String(env, url));
 463     response.setURL(kurl);
 464 
 465     // Setup mime type for local resources
 466     if (/*kurl.hasPath()*/kurl.pathEnd() != kurl.pathStart() && kurl.protocol() == String("file")) {
 467         response.setMimeType(MIMETypeRegistry::getMIMETypeForPath(kurl.path()));
 468     }
 469 }
 470 
 471 JNIEXPORT void JNICALL Java_com_sun_webkit_network_URLLoader_twkDidSendData
 472   (JNIEnv*, jclass, jlong totalBytesSent, jlong totalBytesToBeSent, jlong data)
 473 {
 474     URLLoader::Target* target =
 475             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 476     ASSERT(target);
 477     target->didSendData(totalBytesSent, totalBytesToBeSent);
 478 }
 479 
 480 JNIEXPORT jboolean JNICALL Java_com_sun_webkit_network_URLLoader_twkWillSendRequest
 481   (JNIEnv* env, jclass, jstring newUrl, jstring newMethod, jint status,
 482    jstring contentType, jstring contentEncoding, jlong contentLength,
 483    jstring headers, jstring url, jlong data)
 484 {
 485     URLLoader::Target* target =
 486             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 487     ASSERT(target);
 488 
 489     ResourceResponse response;
 490     setupResponse(
 491             response,
 492             env,
 493             status,
 494             contentType,
 495             contentEncoding,
 496             contentLength,
 497             headers,
 498             url);
 499 
 500     return bool_to_jbool(target->willSendRequest(
 501             String(env, newUrl),
 502             String(env, newMethod),
 503             response));
 504 }
 505 
 506 JNIEXPORT void JNICALL Java_com_sun_webkit_network_URLLoader_twkDidReceiveResponse
 507   (JNIEnv* env, jclass, jint status, jstring contentType,
 508    jstring contentEncoding, jlong contentLength, jstring headers,
 509    jstring url, jlong data)
 510 {
 511     URLLoader::Target* target =
 512             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 513     ASSERT(target);
 514 
 515     ResourceResponse response;
 516     setupResponse(
 517             response,
 518             env,
 519             status,
 520             contentType,
 521             contentEncoding,
 522             contentLength,
 523             headers,
 524             url);
 525 
 526     target->didReceiveResponse(response);
 527 }
 528 
 529 JNIEXPORT void JNICALL Java_com_sun_webkit_network_URLLoader_twkDidReceiveData
 530   (JNIEnv* env, jclass, jobject byteBuffer, jint position, jint remaining,
 531    jlong data)
 532 {
 533     URLLoader::Target* target =
 534             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 535     ASSERT(target);
 536     const char* address =
 537             static_cast<const char*>(env->GetDirectBufferAddress(byteBuffer));
 538     target->didReceiveData(address + position, remaining);
 539 }
 540 
 541 JNIEXPORT void JNICALL Java_com_sun_webkit_network_URLLoader_twkDidFinishLoading
 542   (JNIEnv*, jclass, jlong data)
 543 {
 544     URLLoader::Target* target =
 545             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 546     ASSERT(target);
 547     target->didFinishLoading();
 548 }
 549 
 550 JNIEXPORT void JNICALL Java_com_sun_webkit_network_URLLoader_twkDidFail
 551   (JNIEnv* env, jclass, jint errorCode, jstring url, jstring message,
 552    jlong data)
 553 {
 554     URLLoader::Target* target =
 555             static_cast<URLLoader::Target*>(jlong_to_ptr(data));
 556     ASSERT(target);
 557     target->didFail(ResourceError(
 558             String(),
 559             errorCode,
 560             URL(env, url),
 561             String(env, message)));
 562 }
 563 
 564 #ifdef __cplusplus
 565 }
 566 #endif
--- EOF ---