Synnefo » Pithos Android Client

/*

 * Copyright (C) 2006 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package android.net.http;

import java.security.cert.X509Certificate;

/**

 * One or more individual SSL errors and the associated SSL certificate

 */

public class SslError {

    /**

     * Individual SSL errors (in the order from the least to the most severe):

     */

    /**

     * The certificate is not yet valid

     */

  public static final int SSL_NOTYETVALID = 0;

    /**

     * The certificate has expired

     */

    public static final int SSL_EXPIRED = 1;

    /**

     * Hostname mismatch

     */

    public static final int SSL_IDMISMATCH = 2;

    /**

     * The certificate authority is not trusted

     */

    public static final int SSL_UNTRUSTED = 3;

    /**

     * The number of different SSL errors (update if you add a new SSL error!!!)

     */

    public static final int SSL_MAX_ERROR = 4;

    /**

     * The SSL error set bitfield (each individual error is an bit index;

     * multiple individual errors can be OR-ed)

     */

    int mErrors;

    /**

     * The SSL certificate associated with the error set

     */

    SslCertificate mCertificate;

    /**

     * Creates a new SSL error set object

     * @param error The SSL error

     * @param certificate The associated SSL certificate

     */

    public SslError(int error, SslCertificate certificate) {

        addError(error);

        mCertificate = certificate;

    }

    /**

     * Creates a new SSL error set object

     * @param error The SSL error

     * @param certificate The associated SSL certificate

     */

    public SslError(int error, X509Certificate certificate) {

        addError(error);

        mCertificate = new SslCertificate(certificate);

    }

    /**

     * @return The SSL certificate associated with the error set

     */

    public SslCertificate getCertificate() {

        return mCertificate;

    }

    /**

     * Adds the SSL error to the error set

     * @param error The SSL error to add

     * @return True iff the error being added is a known SSL error

     */

    public boolean addError(int error) {

        boolean rval = (0 <= error && error < SslError.SSL_MAX_ERROR);

        if (rval) {

            mErrors |= (0x1 << error);

        }

        return rval;

    }

    /**

     * @param error The SSL error to check

     * @return True iff the set includes the error

     */

    public boolean hasError(int error) {

        boolean rval = (0 <= error && error < SslError.SSL_MAX_ERROR);

        if (rval) {

            rval = ((mErrors & (0x1 << error)) != 0);

        }

        return rval;

    }

    /**

     * @return The primary, most severe, SSL error in the set

     */

    public int getPrimaryError() {

        if (mErrors != 0) {

            // go from the most to the least severe errors

            for (int error = SslError.SSL_MAX_ERROR - 1; error >= 0; --error) {

                if ((mErrors & (0x1 << error)) != 0) {

                    return error;

                }

            }

        }

        return 0;

    }

    /**

     * @return A String representation of this SSL error object

     * (used mostly for debugging).

     */

    public String toString() {

        return "primary error: " + getPrimaryError() +

            " certificate: " + getCertificate();

    }

}

package android.webkit;

import android.graphics.Bitmap;

import android.net.http.SslError;

import android.os.Message;

import android.view.KeyEvent;

public class WebViewClient {

    /**

     * Give the host application a chance to take over the control when a new

     * url is about to be loaded in the current WebView. If WebViewClient is not

     * provided, by default WebView will ask Activity Manager to choose the

     * proper handler for the url. If WebViewClient is provided, return true

     * means the host application handles the url, while return false means the

     * current WebView handles the url.

     * 

     * @param view The WebView that is initiating the callback.

     * @param url The url to be loaded.

     * @return True if the host application wants to leave the current WebView

     *         and handle the url itself, otherwise return false.

     */

    public boolean shouldOverrideUrlLoading(WebView view, String url) {

        return false;

    }

    /**

     * Notify the host application that a page has started loading. This method

     * is called once for each main frame load so a page with iframes or

     * framesets will call onPageStarted one time for the main frame. This also

     * means that onPageStarted will not be called when the contents of an

     * embedded frame changes, i.e. clicking a link whose target is an iframe.

     * 

     * @param view The WebView that is initiating the callback.

     * @param url The url to be loaded.

     * @param favicon The favicon for this page if it already exists in the

     *            database.

     */

    public void onPageStarted(WebView view, String url, Bitmap favicon) {

    }

    /**

     * Notify the host application that a page has finished loading. This method

     * is called only for main frame. When onPageFinished() is called, the

     * rendering picture may not be updated yet. To get the notification for the

     * new Picture, use {@link WebView.PictureListener#onNewPicture}.

     * 

     * @param view The WebView that is initiating the callback.

     * @param url The url of the page.

     */

    public void onPageFinished(WebView view, String url) {

    }

    /**

     * Notify the host application that the WebView will load the resource

     * specified by the given url.

     * 

     * @param view The WebView that is initiating the callback.

     * @param url The url of the resource the WebView will load.

     */

    public void onLoadResource(WebView view, String url) {

    }

    /**

     * Notify the host application that there have been an excessive number of

     * HTTP redirects. As the host application if it would like to continue

     * trying to load the resource. The default behavior is to send the cancel

     * message.

     * 

     * @param view The WebView that is initiating the callback.

     * @param cancelMsg The message to send if the host wants to cancel

     * @param continueMsg The message to send if the host wants to continue

     */

    public void onTooManyRedirects(WebView view, Message cancelMsg,

            Message continueMsg) {

        cancelMsg.sendToTarget();

    }

    // These ints must match up to the hidden values in EventHandler.

    /** Generic error */

    public static final int ERROR_UNKNOWN = -1;

    /** Server or proxy hostname lookup failed */

    public static final int ERROR_HOST_LOOKUP = -2;

    /** Unsupported authentication scheme (not basic or digest) */

    public static final int ERROR_UNSUPPORTED_AUTH_SCHEME = -3;

    /** User authentication failed on server */

    public static final int ERROR_AUTHENTICATION = -4;

    /** User authentication failed on proxy */

    public static final int ERROR_PROXY_AUTHENTICATION = -5;

    /** Failed to connect to the server */

    public static final int ERROR_CONNECT = -6;

    /** Failed to read or write to the server */

    public static final int ERROR_IO = -7;

    /** Connection timed out */

    public static final int ERROR_TIMEOUT = -8;

    /** Too many redirects */

    public static final int ERROR_REDIRECT_LOOP = -9;

    /** Unsupported URI scheme */

    public static final int ERROR_UNSUPPORTED_SCHEME = -10;

    /** Failed to perform SSL handshake */

    public static final int ERROR_FAILED_SSL_HANDSHAKE = -11;

    /** Malformed URL */

    public static final int ERROR_BAD_URL = -12;

    /** Generic file error */

    public static final int ERROR_FILE = -13;

    /** File not found */

    public static final int ERROR_FILE_NOT_FOUND = -14;

    /** Too many requests during this load */

    public static final int ERROR_TOO_MANY_REQUESTS = -15;

    /**

     * Report an error to the host application. These errors are unrecoverable

     * (i.e. the main resource is unavailable). The errorCode parameter

     * corresponds to one of the ERROR_* constants.

     * @param view The WebView that is initiating the callback.

     * @param errorCode The error code corresponding to an ERROR_* value.

     * @param description A String describing the error.

     * @param failingUrl The url that failed to load.

     */

    public void onReceivedError(WebView view, int errorCode,

            String description, String failingUrl) {

    }

    /**

     * As the host application if the browser should resend data as the

     * requested page was a result of a POST. The default is to not resend the

     * data.

     * 

     * @param view The WebView that is initiating the callback.

     * @param dontResend The message to send if the browser should not resend

     * @param resend The message to send if the browser should resend data

     */

    public void onFormResubmission(WebView view, Message dontResend,

            Message resend) {

        dontResend.sendToTarget();

    }

    /**

     * Notify the host application to update its visited links database.

     * 

     * @param view The WebView that is initiating the callback.

     * @param url The url being visited.

     * @param isReload True if this url is being reloaded.

     */

    public void doUpdateVisitedHistory(WebView view, String url,

            boolean isReload) {

    }

    /**

     * Notify the host application to handle a ssl certificate error request

     * (display the error to the user and ask whether to proceed or not). The

     * host application has to call either handler.cancel() or handler.proceed()

     * as the connection is suspended and waiting for the response. The default

     * behavior is to cancel the load.

     * 

     * @param view The WebView that is initiating the callback.

     * @param handler An SslErrorHandler object that will handle the user's

     *            response.

     * @param error The SSL error object.

     * @hide - hide this because it contains a parameter of type SslError,

     * which is located in a hidden package.

     */

    public void onReceivedSslError(WebView view, SslErrorHandler handler,

            SslError error) {

        handler.cancel();

    }

    /**

     * Notify the host application to handle an authentication request. The

     * default behavior is to cancel the request.

     * 

     * @param view The WebView that is initiating the callback.

     * @param handler The HttpAuthHandler that will handle the user's response.

     * @param host The host requiring authentication.

     * @param realm A description to help store user credentials for future

     *            visits.

     */

    public void onReceivedHttpAuthRequest(WebView view,

            HttpAuthHandler handler, String host, String realm) {

        handler.cancel();

    }

    /**

     * Give the host application a chance to handle the key event synchronously.

     * e.g. menu shortcut key events need to be filtered this way. If return

     * true, WebView will not handle the key event. If return false, WebView

     * will always handle the key event, so none of the super in the view chain

     * will see the key event. The default behavior returns false.

     * 

     * @param view The WebView that is initiating the callback.

     * @param event The key event.

     * @return True if the host application wants to handle the key event

     *         itself, otherwise return false

     */

    public boolean shouldOverrideKeyEvent(WebView view, KeyEvent event) {

        return false;

    }

    /**

     * Notify the host application that a key was not handled by the WebView.

     * Except system keys, WebView always consumes the keys in the normal flow

     * or if shouldOverrideKeyEvent returns true. This is called asynchronously

     * from where the key is dispatched. It gives the host application an chance

     * to handle the unhandled key events.

     * 

     * @param view The WebView that is initiating the callback.

     * @param event The key event.

     */

    public void onUnhandledKeyEvent(WebView view, KeyEvent event) {

    }

    /**

     * Notify the host application that the scale applied to the WebView has

     * changed.

     * 

     * @param view he WebView that is initiating the callback.

     * @param oldScale The old scale factor

     * @param newScale The new scale factor

     */

    public void onScaleChanged(WebView view, float oldScale, float newScale) {

    }

}

			Intent intent = new Intent(this, PithosLoginActivity.class);

			intent.putExtra("login", "https://pithos.dev.grnet.gr/im/login");

			intent.putExtra("auth", Preferences.PITHOS_DEV_SERVER);

			startActivityForResult(intent, 78); // arbitrary number; never used again

			boolean found = false;

			for(Account a : accounts){

				if(a.getUsername().equals(acc.getUsername())&&a.getAuthServer().equals(acc.getAuthServer())){

					a.setPassword(acc.getPassword());

					found=true;

				}

			}

			if(!found)

				accounts.add(acc);

package com.rackspace.cloud.android;

import java.net.URLDecoder;

import java.util.Date;

import java.util.StringTokenizer;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.http.impl.cookie.BasicClientCookie;

import android.app.AlertDialog;

import android.content.DialogInterface;

import android.content.Intent;

import android.net.http.SslError;

import android.os.Build;

import android.os.Bundle;

import android.text.format.DateFormat;

import android.text.method.PasswordTransformationMethod;

import android.util.Log;

import android.webkit.CookieManager;

import android.webkit.CookieSyncManager;

import android.webkit.HttpAuthHandler;

import android.webkit.SslErrorHandler;

import android.webkit.WebSettings.LayoutAlgorithm;

import android.webkit.WebView;

import android.webkit.WebViewClient;

import android.widget.EditText;

import android.widget.LinearLayout;

import android.widget.LinearLayout.LayoutParams;

import android.widget.TextView;

public class PithosLoginActivity extends CloudActivity{

	String loginUrl=null;

	String auth = null;

	public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        trackPageView(GoogleAnalytics.PAGE_PROVIDERS);

        Log.i("LOGIN","START");

        setContentView(R.layout.login);

        loginUrl = getIntent().getExtras().getString("login");

        auth = getIntent().getExtras().getString("auth");

        doLogin();

    } 

	/*

	protected void onSaveInstanceState(Bundle outState) {

		super.onSaveInstanceState(outState);

		//outState.putBoolean("isHidden", isHidden);

	}*/

	private void doLogin(){

		CookieSyncManager.createInstance(this);

		CookieSyncManager.getInstance().startSync();

		final WebView webview = (WebView) findViewById(R.id.browser);//new WebView(this);

		webview.getSettings().setJavaScriptEnabled(true);

		// webview.setHttpAuthUsernamePassword("vho.grnet.gr", "VHO login",

		// "ebs-koutsoub", "mwJBdgbtv");

		webview.clearCache(true);

		webview.clearFormData();

		webview.clearHistory();

		webview.getSettings().setBuiltInZoomControls(true);

		//webview.getSettings().setDefaultZoom(ZoomDensity.);

		if(Build.VERSION.SDK_INT!=7)

			webview.getSettings().setLayoutAlgorithm(LayoutAlgorithm.SINGLE_COLUMN);

		webview.setWebViewClient(new WebViewClient() {

			public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error){

		          handler.proceed();

		     }

			  @Override public boolean shouldOverrideUrlLoading(WebView view,

			  String url) { 

				  view.loadUrl(url); return true;

			  }

			@Override

			public void onPageFinished(WebView view, String url) {

				super.onPageFinished(view, url);

				//webview.loadUrl("javascript:window.HTMLOUT.showHTML('<head>'+document.getElementsByTagName('html')[0].innerHTML+'</head>');");

				CookieSyncManager.getInstance().sync();

				String cookie = CookieManager.getInstance().getCookie(url);

				Log.i("LOGIN COOKIE","c: "+cookie);

				if(null!=cookie && cookie.startsWith("_pithos2_a")){

					try {

						String value = URLDecoder.decode(parseRawCookie(cookie).getValue());

						StringTokenizer str = new StringTokenizer(value,"|");

						if(str.countTokens()==2){

							String u = str.nextToken();

							String t = str.nextToken();

							Log.i("value",value);

							Log.i("s1",u);

							Log.i("s2",t);

							exit(u,t);

						}

						//exit(s[0], s[1]);

					} catch (Exception e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

				}

			}

			@Override

			public void onReceivedHttpAuthRequest(WebView view,

					final HttpAuthHandler handler, String host, String realm) {

				String[] up = view.getHttpAuthUsernamePassword(host, realm);

				if (up != null && up.length == 2) {

					handler.proceed(up[0], up[1]);

				} else {

						final AlertDialog.Builder alert = new AlertDialog.Builder(PithosLoginActivity.this);

			        	alert.setTitle("Pithos Login");

			        	//View lv = findViewById(R.layout.dialoglogin);

			        	//alert.setView(lv);

			    		final EditText input = new EditText(PithosLoginActivity.this);//(EditText) lv.findViewById(R.id.username); 

			    		final EditText pass = new EditText(PithosLoginActivity.this);//(EditText) lv.findViewById(R.id.password);

			    		pass.setTransformationMethod(new PasswordTransformationMethod());

			    		LinearLayout layout = new LinearLayout(PithosLoginActivity.this);

			    		layout.setOrientation(LinearLayout.VERTICAL);

			    		LayoutParams params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);

			    		layout.setLayoutParams(params);

			    		input.setLayoutParams(params);

			    		pass.setLayoutParams(params);

			    		TextView username = new TextView(PithosLoginActivity.this);

			    		username.setText("Username:");

			    		TextView password = new TextView(PithosLoginActivity.this);

			    		password.setText("Password:");

			    		layout.addView(username);

			    		layout.addView(input);

			    		layout.addView(password);

			    		layout.addView(pass);

			    		alert.setView(layout);

			    		alert.setPositiveButton("Login", new DialogInterface.OnClickListener() {

			    			public void onClick(DialogInterface dialog, int whichButton) {

			    				String uvalue = input.getText().toString().trim();

			    				String pvalue = pass.getText().toString().trim();

			    				handler.proceed(uvalue, pvalue);			    				

			    			}

			    		});

			    		alert.setNegativeButton("Cancel",

			    				new DialogInterface.OnClickListener() {

			    					public void onClick(DialogInterface dialog, int whichButton) {

			    						dialog.cancel();

			    					}

			    				});

			    		alert.show();

					}

				}

		});

		Log.i("LOGIN","LOADING:"+loginUrl);

		//setContentView(webview);

		webview.clearSslPreferences();

		webview.loadUrl("https://pithos.dev.grnet.gr/im/login/invitation?code=6879429392467020041");

		//webview.loadUrl("http://www.google.gr");

	}

	void exit(String username,String token){

		Log.i("LOGINA",username+" "+token);

		Intent result = new Intent();

		Bundle b = new Bundle();

		b.putString("username", username);

		b.putString("apiKey", token);

		b.putString("server", auth);

		result.putExtra("accountInfo", b);

		setResult(RESULT_OK, result);

		finish();

	}

	BasicClientCookie parseRawCookie(String rawCookie) throws Exception {

	    String[] rawCookieParams = rawCookie.split(";");

	    String[] rawCookieNameAndValue = rawCookieParams[0].split("=");

	    if (rawCookieNameAndValue.length != 2) {

	        throw new Exception("Invalid cookie: missing name and value.");

	    }

	    String cookieName = rawCookieNameAndValue[0].trim();

	    String cookieValue = rawCookieNameAndValue[1].trim();

	    BasicClientCookie cookie = new BasicClientCookie(cookieName, cookieValue);

	    for (int i = 1; i < rawCookieParams.length; i++) {

	        String rawCookieParamNameAndValue[] = rawCookieParams[i].trim().split("=");

	        String paramName = rawCookieParamNameAndValue[0].trim();

	        if (paramName.equalsIgnoreCase("secure")) {

	            cookie.setSecure(true);

	        } else {

	            if (rawCookieParamNameAndValue.length != 2) {

	                throw new Exception("Invalid cookie: attribute not a flag or missing value.");

	            }

	            String paramValue = rawCookieParamNameAndValue[1].trim();

	        }

	    }

	    return cookie;

	}

}

		get.addHeader("X-Auth-Key",  Account.getAccount().getPassword());//"lMvqjHxChbQY+LgDqwWpYg==");//

				BasicResponseHandler responseHandler = new BasicResponseHandler();

				String body = responseHandler.handleResponse(resp);