virtual void GetResponseHeaders(CefRefPtr<CefResponse> response, int64& response_length, CefString& redirectUrl)
	{
		response->SetMimeType(mimeType_);

		if (file_ == -1)
		{
			response->SetStatus(404);
		}
		else
		{
			response->SetStatus(200);
		}

		CefResponse::HeaderMap map;
		response->GetHeaderMap(map);

		map.insert(std::make_pair("cache-control", "no-cache, must-revalidate"));
		response->SetHeaderMap(map);

		if (file_ != -1)
		{
			response_length = device_->fileLength(file_);
		}
		else
		{
			response_length = 0;
		}
	}
JNIEXPORT void JNICALL Java_org_cef_network_CefResponse_1N_N_1SetHeaderMap
  (JNIEnv *env, jobject obj, jobject jheaderMap) {
  CefRefPtr<CefResponse> response = GetCefFromJNIObject<CefResponse>(env, obj, "CefResponse");
  if (!response)
    return;

  // public abstract java.util.Set<java.util.Map$Entry<K, V>> entrySet();
  jobject entrySet = NULL;
  JNI_CALL_METHOD(env, jheaderMap,
                  "entrySet",
                  "()Ljava/util/Set;",
                  Object,
                  entrySet);
  if (!entrySet)
    return;

  // public abstract java.lang.Object[] toArray();
  jobject entrySetValues = NULL;
  JNI_CALL_METHOD(env, entrySet,
                  "toArray",
                  "()[Ljava/lang/Object;",
                  Object,
                  entrySetValues);
  if (!entrySetValues)
    return;

  CefResponse::HeaderMap headerMap;
  jint length = env->GetArrayLength((jobjectArray)entrySetValues);
  for (jint i=0; i < length; i++) {
    jobject mapEntry = env->GetObjectArrayElement((jobjectArray)entrySetValues, i);
    if (!mapEntry)
      return;
    jobject key = NULL;
    jobject value = NULL;
    JNI_CALL_METHOD(env, mapEntry,
                    "getKey",
                    "()Ljava/lang/Object;",
                    Object,
                    key);
    JNI_CALL_METHOD(env, mapEntry,
                    "getValue",
                    "()Ljava/lang/Object;",
                    Object,
                    value);
    headerMap.insert(std::make_pair(GetJNIString(env, (jstring)key), GetJNIString(env, (jstring)value)));
  }
  response->SetHeaderMap(headerMap);
}
Exemple #3
0
void DumpResponseContents(CefRefPtr<CefResponse> response, std::string& str)
{
  std::stringstream ss;
  //ss << "MIME: " << response->GetMimeType() << "\n";
  CefResponse::HeaderMap headerMap;
  response->GetHeaderMap(headerMap);
  if(headerMap.size() > 0) 
  {
    ss << "\nHeaders:";
    CefResponse::HeaderMap::const_iterator it = headerMap.begin();
    for(; it != headerMap.end(); ++it) 
    {
      ss << "\n\t" << std::string((*it).first) << ": " <<
          std::string((*it).second);
    }
  }
  str = ss.str();  
}
JNIEXPORT void JNICALL Java_org_cef_network_CefResponse_1N_N_1GetHeaderMap
  (JNIEnv *env, jobject obj, jobject jheaderMap) {
  CefRefPtr<CefResponse> response = GetCefFromJNIObject<CefResponse>(env, obj, "CefResponse");
  if (!response)
    return;  
  CefResponse::HeaderMap headerMap;
  response->GetHeaderMap(headerMap);

  for (CefResponse::HeaderMap::iterator iter = headerMap.begin(); iter != headerMap.end(); ++iter) {
    jstring jkey = NewJNIString(env, iter->first);
    jstring jvalue = NewJNIString(env, iter->second);
    jobject returnIgn = NULL;
    JNI_CALL_METHOD(env,
                    jheaderMap,
                    "put",
                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
                    Object,
                    returnIgn,
                    jkey,
                    jvalue);
    UNUSED(returnIgn);
  }
}
Exemple #5
0
    CefRefPtr<CefResourceHandler> RequestHandler::GetResourceHandler(CefRefPtr<CefBrowser> browser,
                                                                     CefRefPtr<CefFrame> frame,
                                                                     CefRefPtr<CefRequest> request) {
        std::string url = request->GetURL().ToString();
        std::string method = request->GetMethod().ToString();

        int split_index = url.find_first_of('?');
        std::string base_url;
        std::string get_params;
        if (split_index == -1) {
            base_url = url;
        } else {
            base_url = url.substr(0, split_index);
            get_params = url.substr(split_index + 1);
        }

        bool found = false;
        Route *route = nullptr;
        std::vector<Route *>::iterator route_iter = routes.begin();
        while (route_iter != routes.end() && !found) {
            route = (*route_iter);
            std::smatch match;
            if (std::regex_search(base_url, match, route->RouteRegex())) {
                found = true;
            }
            ++route_iter;
        }

        if (found) {
            std::vector<std::pair<std::string, std::string> > get;
            std::vector<std::string> get_param_chunks = split(get_params, '&');
            std::vector<std::string>::iterator get_param_chunk_iter = get_param_chunks.begin();
            while (get_param_chunk_iter != get_param_chunks.end()) {
                std::string chunk = (*get_param_chunk_iter);
                std::string name = chunk.substr(0, chunk.find_first_of('='));
                std::string value = chunk.substr(chunk.find_first_of('='));
                get.push_back(std::pair<std::string, std::string>(name, value));
                ++get_param_chunk_iter;
            }

            std::vector<std::pair<std::string, std::string> > post;
            CefRefPtr<CefPostData> post_data = request->GetPostData();
            if (post_data.get() != nullptr) {
                CefPostData::ElementVector post_elements;
                post_data->GetElements(post_elements);
                CefPostData::ElementVector::iterator post_elem_iter = post_elements.begin();
                while (post_elem_iter != post_elements.end()) {
                    std::string element_data;
                    std::string element_type;
                    CefRefPtr<CefPostDataElement> element = (*post_elem_iter);
                    if (element->GetType() == PDE_TYPE_EMPTY) {
                        element_type = "empty";
                    } else if (element->GetType() == PDE_TYPE_BYTES) {
                        element_data = ReadPostElementBytes(element);
                        element_type = "string";
                    } else if (element->GetType() == PDE_TYPE_FILE) {
                        element_data = element->GetFile().ToString();
                        element_type = "file";
                    }
                    post.push_back(std::pair<std::string, std::string>(element_type, element_data));
                    ++post_elem_iter;
                }
            }

            Response *result = route->Call(base_url, method, get, post);
            if (result == nullptr) {
                return nullptr;
            }

            std::string content_str = result->GetContent();
            int content_size = content_str.size();
            const char *content = content_str.c_str();

            CefRefPtr<CefStreamReader> result_stream = CefStreamReader::CreateForData(
                                                           static_cast<void*>(const_cast<char*>(content)), content_size);
            CefResponse::HeaderMap headers;
            headers.insert(std::pair<CefString, CefString>("Access-Control-Allow-Origin", "*"));
            headers.insert(std::pair<CefString, CefString>("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept"));
            headers.insert(std::pair<CefString, CefString>("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, PATCH, DELETE"));

            return new CefStreamResourceHandler(200, "200 OK", result->GetMimeType(), headers, result_stream);
        }

        return nullptr;
    }