@Test public void testConnectionBasedAuthOnlyIfChallenged() throws Exception { HttpRequest request = new BasicHttpRequest("GET", "/"); HttpContext context = new BasicHttpContext(); AuthState authstate = new AuthState(); BasicScheme authscheme = new BasicScheme() { @Override public boolean isConnectionBased() { return true; } }; BasicHeader challenge = new BasicHeader(AUTH.WWW_AUTH, "BASIC realm=auth-realm"); authscheme.processChallenge(challenge); Credentials creds = new UsernamePasswordCredentials("user", "secret"); authstate.setState(AuthProtocolState.SUCCESS); authstate.update(authscheme, creds); context.setAttribute(ClientContext.TARGET_AUTH_STATE, authstate); HttpRequestInterceptor interceptor = new RequestTargetAuthentication(); interceptor.process(request, context); Header header = request.getFirstHeader(AUTH.WWW_AUTH_RESP); Assert.assertNull(header); }
@Override public boolean retryRequest(IOException exception, int executionCount, HttpContext context) { boolean retry = true; Boolean b = (Boolean) context.getAttribute(ExecutionContext.HTTP_REQ_SENT); boolean sent = (b != null && b.booleanValue()); if (executionCount > maxRetries) { // 尝试次数超过用户定义的测试,默认5次 retry = false; } else if (exceptionBlacklist.contains(exception.getClass())) { // 线程被用户中断,则不继续尝试 retry = false; } else if (exceptionWhitelist.contains(exception.getClass())) { retry = true; } else if (!sent) { retry = true; } if (retry) { HttpUriRequest currentReq = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); retry = currentReq != null && !"POST".equals(currentReq.getMethod()); } if (retry) { // 休眠1秒钟后再继续尝试 SystemClock.sleep(RETRY_SLEEP_TIME_MILLIS); } else { exception.printStackTrace(); } return retry; }
public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE); if (authState.getAuthScheme() != null) { return; } AuthScheme authScheme = (AuthScheme) context.getAttribute("preemptive-auth"); if (authScheme == null) { return; } CredentialsProvider credsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER); HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); Credentials creds = credsProvider.getCredentials( new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds == null) { return; } authState.setAuthScheme(authScheme); authState.setCredentials(creds); }
static void testProtectedResource() throws ClientProtocolException, IOException { HttpClient httpclient = new DefaultHttpClient(); HttpContext localContext = new BasicHttpContext(); HttpGet httpget = new HttpGet(url); HttpResponse response = httpclient.execute(httpget, localContext); AuthState proxyAuthState = (AuthState) localContext.getAttribute(ClientContext.PROXY_AUTH_STATE); System.out.println("Proxy auth scope: " + proxyAuthState.getAuthScope()); System.out.println("Proxy auth scheme: " + proxyAuthState.getAuthScheme()); System.out.println("Proxy auth credentials: " + proxyAuthState.getCredentials()); AuthState targetAuthState = (AuthState) localContext.getAttribute(ClientContext.TARGET_AUTH_STATE); System.out.println("Target auth scope: " + targetAuthState.getAuthScope()); System.out.println("Target auth scheme: " + targetAuthState.getAuthScheme()); System.out.println("Target auth credentials: " + targetAuthState.getCredentials()); HttpEntity entity = response.getEntity(); String charset = HttpclientTutorial.getResponseCharset(response); System.out.println("charset:" + charset); HttpclientTutorial.output(entity, charset); EntityUtils.consume(entity); }
public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE); if (authState.getAuthScheme() != null || authState.hasAuthOptions()) { return; } // If no authState has been established and this is a PUT or POST request, add preemptive // authorisation String requestMethod = request.getRequestLine().getMethod(); if (requestMethod.equals(HttpPut.METHOD_NAME) || requestMethod.equals(HttpPost.METHOD_NAME)) { CredentialsProvider credentialsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER); HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); Credentials credentials = credentialsProvider.getCredentials( new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (credentials == null) { throw new HttpException("No credentials for preemptive authentication"); } authState.update(authScheme, credentials); } }
@Test public void testPreemptiveAuthenticationFailure() throws Exception { CountingAuthHandler requestHandler = new CountingAuthHandler(); this.localServer.register("*", requestHandler); this.localServer.start(); BasicCredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("test", "stuff")); this.httpclient.setCredentialsProvider(credsProvider); HttpHost targethost = getServerHttp(); HttpContext context = new BasicHttpContext(); AuthCache authCache = new BasicAuthCache(); authCache.put(targethost, new BasicScheme()); context.setAttribute(ClientContext.AUTH_CACHE, authCache); HttpGet httpget = new HttpGet("/"); HttpResponse response1 = this.httpclient.execute(targethost, httpget, context); HttpEntity entity1 = response1.getEntity(); Assert.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getStatusLine().getStatusCode()); Assert.assertNotNull(entity1); EntityUtils.consume(entity1); Assert.assertEquals(1, requestHandler.getCount()); }
public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE); if (request.getFirstHeader("Authorization") != null) { // Using OAuth, leave as is } else if (request.getFirstHeader("X-No-Auth") != null) { // No auth required, leave as is } else { // If no auth scheme avaialble yet, try to initialize it preemptively if (authState.getAuthScheme() == null) { AuthScheme authScheme = (AuthScheme) context.getAttribute("preemptive-auth"); CredentialsProvider credsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER); HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); if (authScheme != null) { Credentials creds = credsProvider.getCredentials( new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds == null) { throw new HttpException("No credentials for preemptive authentication"); } else { authState.setAuthScheme(authScheme); authState.setCredentials(creds); } } } } }
public void doReadLoop() { HttpContext context = new BasicHttpContext(); context.setAttribute(CX_SOCKET, rawSocket); while (!Thread.interrupted() && this.htConn.isOpen() && HttpServer.this.shouldRun) { // Clear the context from any auth settings; since this is done // anew on each connection.. context.removeAttribute(CX_AUTH); try { HttpServer.this.httpService.handleRequest(htConn, context); } catch (ConnectionClosedException ex_closed) { break; } catch (IOException ex) { if (!closeRequested) { ex.printStackTrace(); } break; } catch (HttpException ex) { ex.printStackTrace(); break; } catch (ResponseHandledException ex) { break; } } bail(); }
@Override public boolean retryRequest(IOException e, int executionCount, HttpContext context) { boolean retry = true; Boolean b = (Boolean) context.getAttribute(ExecutionContext.HTTP_REQ_SENT); boolean sent = (b != null && b); if (executionCount > maxRetries) { retry = false; } else if (isInList(exceptionWhiteList, e)) { retry = true; } else if (isInList(exceptionBlackList, e)) { retry = false; } else if (!sent) { retry = true; } if (retry) { HttpUriRequest request = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); if (request == null) { return false; } } if (retry) { SystemClock.sleep(retrySleepTimeMS); } else { e.printStackTrace(); } return retry; }
@Override protected Void doInBackground(Void... params) { // TODO Auto-generated method stub try { apiParams = new ArrayList<NameValuePair>(); apiParams.add( new BasicNameValuePair( AppProperties.DATABASE, session.getValue(AppProperties.DATABASE))); apiParams.add( new BasicNameValuePair("profileid", session.getValue(AppProperties.PROFILE_ID))); apiParams.add(new BasicNameValuePair("chat_sent_time", last_chat_time)); apiParams.add(new BasicNameValuePair("userid", userid)); apiParams.add(new BasicNameValuePair("name", "Brijesh Kushwaha")); apiParams.add(new BasicNameValuePair("message", msg)); apiParams.add( new BasicNameValuePair( "photo", "https://ebdd192075d95c350eef-28241eefd51f43f0990a7c61585ebde0.ssl.cf2.rackcdn.com/1000000002_1405785647.jpg")); apiParams.add(new BasicNameValuePair("auth", session.getValue(AppProperties.PROFILE_ID))); apiParams.add( new BasicNameValuePair("PHPSESSID", session.getValue(AppProperties.SESSION_ID))); Log.e("Chat NEW Parameters", apiParams.toString()); Log.e("url", url); post = new HttpPost(url); post.addHeader("PHPSESSID", session.getValue(AppProperties.SESSION_ID)); Log.e("PHPSESSID", session.getValue(AppProperties.SESSION_ID)); post.setEntity(new UrlEncodedFormEntity(apiParams)); BasicCookieStore cookieStore = new BasicCookieStore(); HttpClient client = new DefaultHttpClient(); // Create local HTTP context HttpContext localContext = new BasicHttpContext(); // Bind custom cookie store to the local context localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); rChatUpdate = client.execute(post); status = rChatUpdate.getStatusLine().getStatusCode(); System.out.println("Stage -1"); if (status == 200) { System.out.println("Satus 200 obtained from Quipmate"); HttpEntity e = rChatUpdate.getEntity(); System.out.println("Stage 1"); String d = EntityUtils.toString(e); if (d != null) { Log.e("Chat", d.toString()); } } } catch (Exception e) { System.out.println("Some Unknown exception occured"); e.printStackTrace(); } return null; }
@Override protected HttpContext createHttpContext() { HttpContext context = new BasicHttpContext(); context.setAttribute(ClientContext.SCHEME_REGISTRY, getConnectionManager().getSchemeRegistry()); context.setAttribute(ClientContext.AUTHSCHEME_REGISTRY, getAuthSchemes()); context.setAttribute(ClientContext.COOKIESPEC_REGISTRY, getCookieSpecs()); context.setAttribute(ClientContext.COOKIE_STORE, getCookieStore()); context.setAttribute(ClientContext.CREDS_PROVIDER, getCredentialsProvider()); return context; }
public void exception(NHttpServerConnection conn, Exception ex) { if (ex instanceof IOException) { logIOException(conn, (IOException) ex); metrics.incrementFaultsReceiving(); ProtocolState state = SourceContext.getState(conn); if (state == ProtocolState.REQUEST_BODY || state == ProtocolState.REQUEST_HEAD) { informReaderError(conn); } else if (state == ProtocolState.RESPONSE_BODY || state == ProtocolState.RESPONSE_HEAD) { informWriterError(conn); } else if (state == ProtocolState.REQUEST_DONE) { informWriterError(conn); } else if (state == ProtocolState.RESPONSE_DONE) { informWriterError(conn); } SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn); } else if (ex instanceof HttpException) { try { if (conn.isResponseSubmitted()) { sourceConfiguration.getSourceConnections().shutDownConnection(conn); return; } HttpContext httpContext = conn.getContext(); HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_BAD_REQUEST, "Bad request"); response.setParams( new DefaultedHttpParams(sourceConfiguration.getHttpParams(), response.getParams())); response.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE); // Pre-process HTTP request httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); httpContext.setAttribute(ExecutionContext.HTTP_REQUEST, null); httpContext.setAttribute(ExecutionContext.HTTP_RESPONSE, response); sourceConfiguration.getHttpProcessor().process(response, httpContext); conn.submitResponse(response); SourceContext.updateState(conn, ProtocolState.CLOSED); conn.close(); } catch (Exception ex1) { log.error(ex.getMessage(), ex); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn); } } else { log.error("Unexoected error: " + ex.getMessage(), ex); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn); } }
@Test public void testAuthStateNotSet() throws Exception { HttpRequest request = new BasicHttpRequest("GET", "/"); HttpContext context = new BasicHttpContext(); context.setAttribute(ClientContext.TARGET_AUTH_STATE, null); HttpRequestInterceptor interceptor = new RequestTargetAuthentication(); interceptor.process(request, context); Header header = request.getFirstHeader(AUTH.WWW_AUTH_RESP); Assert.assertNull(header); }
/** * Return the HTTP Get result as String given these parameters. * * @param url The url for the Get request. * @param cookies The cookie String to be appended to the request. * @param domain The domain to be set into the cookie if any. * @return String The result of the HTTP Get request. */ private String getHttpGetResponseString(String url, String cookies, String domain) { StringBuilder total = new StringBuilder(); BufferedReader r = null; try { HttpClient httpclient = new DefaultHttpClient(); HttpGet httpget = new HttpGet(url); HttpContext localContext = new BasicHttpContext(); if (cookies != null) { // Split the Cookie string into cookies, and put them into the HttpContext BasicCookieStore cookieStore = new BasicCookieStore(); StringTokenizer st = new StringTokenizer(cookies, "[;]"); while (st.hasMoreElements()) { String ele = (String) st.nextElement(); int splitterIdx = ele.indexOf('='); String key = ele.substring(0, splitterIdx); String val = ele.substring(splitterIdx + 1, ele.length()); BasicClientCookie cookie = new BasicClientCookie(key, val); if (domain != null) cookie.setDomain(domain); cookie.setSecure(false); cookie.setVersion(0); cookieStore.addCookie(cookie); } localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); } // Execute HTTP Post Request HttpResponse response = httpclient.execute(httpget, localContext); r = new BufferedReader(new InputStreamReader(response.getEntity().getContent())); String line = null; while ((line = r.readLine()) != null) { total.append(line); } } catch (ClientProtocolException e) { e.printStackTrace(); } catch (OutOfMemoryError e) { // e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (r != null) r.close(); } catch (IOException e) { e.printStackTrace(); } } return total.toString(); }
public void process(final HttpResponse response, final HttpContext context) throws HttpException, IOException { AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE); if (authState != null) { AuthScheme authScheme = authState.getAuthScheme(); // Stick the auth scheme to the local context, so // we could try to authenticate subsequent requests // preemptively if (authScheme instanceof DigestScheme) { context.setAttribute("preemptive-auth", authScheme); } } }
public static HttpResponse post( String url, List<NameValuePair> params, RequestConfig config, CookieStore cookieStore) throws IOException { CloseableHttpClient client = HttpClients.custom().setUserAgent(Constants.DEFAULT_USER_AGENT).build(); HttpContext localContext = new BasicHttpContext(); localContext.setAttribute(HttpClientContext.COOKIE_STORE, cookieStore); HttpPost post = new HttpPost(url); post.setEntity(new UrlEncodedFormEntity(params)); post.setConfig(config); HttpResponse response = client.execute(post, localContext); return response; }
private static String getUrlAfterRedirects(HttpContext context) { String lastRedirectUrl = (String) context.getAttribute(LAST_REDIRECT_URL); if (lastRedirectUrl != null) return lastRedirectUrl; else { HttpUriRequest currentReq = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); HttpHost currentHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); String currentUrl = (currentReq.getURI().isAbsolute()) ? currentReq.getURI().toString() : (currentHost.toURI() + currentReq.getURI()); return currentUrl; } }
public void signUp(View view) { EditText email = (EditText) findViewById(R.id.email); EditText pw = (EditText) findViewById(R.id.password); EditText nameField = (EditText) findViewById(R.id.name); String username = email.getText().toString(); String password = pw.getText().toString(); String name = nameField.getText().toString(); try { URI uri = new URI("http://severe-leaf-6733.herokuapp.com/users"); DefaultHttpClient client = new DefaultHttpClient(); HttpPost post = new HttpPost(uri); JSONObject json = new JSONObject(); JSONObject m = new JSONObject(); m.put("name", name); m.put("email", username); m.put("password", password); json.put("user", m); StringEntity se = new StringEntity(json.toString()); post.setEntity(se); post.setHeader("Accept", "application/json"); post.setHeader("Content-type", "application/json"); BasicResponseHandler responseHandler = new BasicResponseHandler(); String responseString = client.execute(post, responseHandler); GsonBuilder g = new GsonBuilder(); g.setDateFormat("E MMM d HH:mm:ss Z y"); Gson gson = g.create(); User um = gson.fromJson(responseString, User.class); if (um.getID() != 0) { CookieStore cookieStore = client.getCookieStore(); HttpContext localContext = new BasicHttpContext(); localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); Global.localContext = localContext; Global.client = client; Global.user_id = um.getID(); Intent myIntent = new Intent(getApplicationContext(), Root.class); startActivity(myIntent); } else { Toast.makeText(this, "Unable to Sign Up", Toast.LENGTH_LONG).show(); } } catch (Exception e) { Log.e("Sign Up Error", e.getMessage()); } }
@Override public void run() { uploadInitialising(); try { if (fireDriveAccount.loginsuccessful) { httpContext = fireDriveAccount.getHttpContext(); if (fireDriveAccount.isPremium()) { maxFileSizeLimit = 53687091200l; // 50 GB } else { maxFileSizeLimit = 1073741824l; // 1 GB } } else { httpContext.setAttribute(ClientContext.COOKIE_STORE, new BasicCookieStore()); } if (file.length() > maxFileSizeLimit) { throw new NUMaxFileSizeException(maxFileSizeLimit, file.getName(), getHost()); } normalUpload(); uploadFinished(); } catch (NUException ex) { ex.printError(); uploadInvalid(); } catch (Exception e) { NULogger.getLogger().log(Level.INFO, "Exception: {0}", e); uploadFailed(); } }
@Override public void process(HttpResponse response, HttpContext context) throws HttpException, IOException { CookieStore cookieStore = (CookieStore) context.getAttribute(ClientContext.COOKIE_STORE); for (Header header : response.getAllHeaders()) { if (!header.getName().equalsIgnoreCase("Set-Cookie")) { continue; } Matcher matcher = pattern.matcher(header.getValue()); if (!matcher.find()) { continue; } for (Cookie cookie : cookieStore.getCookies()) { if (cookie.getName().equalsIgnoreCase(matcher.group(1))) { if (cookie instanceof BasicClientCookie) { ((BasicClientCookie) cookie).setValue('"' + cookie.getValue() + '"'); } else if (cookie instanceof BasicClientCookie2) { ((BasicClientCookie2) cookie).setValue('"' + cookie.getValue() + '"'); } else { Log.w(TAG, "unhandled cookie implementation " + cookie.getClass().getName()); } break; } } } }
@Override public boolean retryRequest( IOException exception, int executionCount, HttpContext context) { // 设置恢复策略,在发生异常时候将自动重试N次 if (executionCount >= RETRIED_TIME) { // Do not retry if over max retry count Logger.getLogger().e("Do not retry if over max retry count:" + executionCount); return false; } if (exception instanceof NoHttpResponseException) { // Retry if the server dropped connection on us Logger.getLogger() .i( "Retry if the server dropped connection on us:exception instanceof NoHttpResponseException"); return true; } if (exception instanceof SSLHandshakeException) { // Do not retry on SSL handshake exception Logger.getLogger().e("Do not retry on SSL handshake SSLHandshakeException "); return false; } HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); boolean idempotent = (request instanceof HttpEntityEnclosingRequest); if (!idempotent) { // Retry if the request is considered idempotent Logger.getLogger().i("Retry if the request is considered idempotent"); return true; } return false; }
public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { Locale locale = Locale.getDefault(); request.setHeader( "Accept-Language", (locale.getLanguage() + "-" + locale.getCountry()).toLowerCase()); request.setHeader("Accept-Encoding", "gzip"); AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE); // HttpHost targetHost = (HttpHost) // context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); if (true /*(INFO.HOST_IP.equals(targetHost.getHostName())) && (INFO.HOST_PORT == targetHost.getPort())*/) { authState.setAuthScheme(new BasicScheme()); /* username = "******"; password = "******";*/ if (username == null) { // username = appContext.getSharedPreferences(BaseActivity.SETTING_INFOS, // Context.MODE_PRIVATE).getString(BaseActivity.NAME, null); // password = appContext.getSharedPreferences(BaseActivity.SETTING_INFOS, // Context.MODE_PRIVATE).getString(BaseActivity.PASSWORD, null); } // INFO.Log("username", username+""); if (username != null) { authState.setCredentials(new UsernamePasswordCredentials(username, password)); } } }
/** * 设置Cookie 方法2 * * <p>httpclient.execute(request, context) 方法进行添加 * * @param cookies * @return */ public HttpContext getetRequestCookieContext(Map<String, String> cookies) { HttpContext localContext = null; if (cookies != null && cookies.size() > 0) { BasicCookieStore cookieStore = new BasicCookieStore(); for (Entry<String, String> c : cookies.entrySet()) { BasicClientCookie cookie = new BasicClientCookie(c.getKey(), c.getValue()); cookie.setDomain("sina.com"); cookie.setPath("/"); cookieStore.addCookie(cookie); } localContext = new BasicHttpContext(); localContext.setAttribute(HttpClientContext.COOKIE_STORE, cookieStore); } return localContext; }
@Override public void run() { try { if (file.length() > fileSizeLimit) { throw new NUMaxFileSizeException(fileSizeLimit, file.getName(), this.getHost()); } if (solidfilesAccount.loginsuccessful) { httpContext = solidfilesAccount.getHttpContext(); } else { cookieStore = new BasicCookieStore(); httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); } uploadInitialising(); fileupload(); } catch (NUException ex) { ex.printError(); uploadInvalid(); } catch (Exception e) { Logger.getLogger(Solidfiles.class.getName()).log(Level.SEVERE, null, e); uploadFailed(); } }
public void setRequest( com.hzth.myapp.myHttpClient.protocol.Request request, CallbackInterface callback) throws Exception { super.setRequest(request, callback); // request settings int port = request.getUrl().getPort(); context = new BasicHttpContext(null); host = new HttpHost(request.getUrl().getHost(), port == -1 ? 80 : port); conn = new DefaultHttpClientConnection(); connStrategy = new DefaultConnectionReuseStrategy(); context.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, host); }
private void createContext() { synchronized (lock) { if (context == null) { context = new BasicHttpContext(); cookieStore = new BasicCookieStore(); context.setAttribute(ClientContext.COOKIE_STORE, cookieStore); } } }
public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); UserPasswordAuthentication creds; synchronized (this) { creds = credentials.get(targetHost); } if (creds != null) { AuthScope scope = new AuthScope(targetHost); BasicCredentialsProvider credProvider = new BasicCredentialsProvider(); credProvider.setCredentials( scope, new UsernamePasswordCredentials(creds.getUsername(), creds.getPassword())); context.setAttribute(ClientContext.CREDS_PROVIDER, credProvider); } }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { AuthState authState = (AuthState) context.getAttribute(HttpClientContext.TARGET_AUTH_STATE); if (authState.getAuthScheme() == null) { Credentials creds = new UsernamePasswordCredentials(myUsername, myPassword); authState.update(new BasicScheme(), creds); } }
public static String getRedirectedUrl(String url) { DefaultHttpClient client = new DefaultHttpClient(); HttpGet get = new HttpGet(url); try { HttpContext context = new BasicHttpContext(); HttpResponse response = client.execute(get, context); if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) throw new IOException(response.getStatusLine().toString()); HttpUriRequest currentReq = (HttpUriRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); HttpHost currentHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST); return currentHost.toURI() + currentReq.getURI(); } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return url; }
public static HttpResponse get( String url, List<NameValuePair> params, RequestConfig config, CookieStore cookieStore) throws IOException { CloseableHttpClient client = HttpClients.custom().setUserAgent(Constants.DEFAULT_USER_AGENT).build(); HttpContext localContext = new BasicHttpContext(); localContext.setAttribute(HttpClientContext.COOKIE_STORE, cookieStore); String reqUrl = ""; if (params != null && params.size() > 0) { reqUrl = url + "?" + URLEncodedUtils.format(params, "utf-8"); } else { reqUrl = url; } HttpGet get = new HttpGet(reqUrl); get.setConfig(config); HttpResponse response = client.execute(get, localContext); return response; }