package Extensions;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.nio.charset.Charset;
    import java.security.KeyManagementException;
    import java.security.KeyStore;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.UnrecoverableKeyException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;

    import javax.net.ssl.SSLContext;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;

    import org.apache.http.HeaderElement;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpVersion;
    import org.apache.http.NameValuePair;
    import org.apache.http.StatusLine;
    import org.apache.http.auth.UsernamePasswordCredentials;
    import org.apache.http.client.methods.HttpRequestBase;
    import org.apache.http.conn.ClientConnectionManager;
    import org.apache.http.conn.scheme.PlainSocketFactory;
    import org.apache.http.conn.scheme.Scheme;
    import org.apache.http.conn.scheme.SchemeRegistry;
    import org.apache.http.conn.ssl.SSLSocketFactory;
    import org.apache.http.impl.auth.BasicScheme;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
    import org.apache.http.params.BasicHttpParams;
    import org.apache.http.params.HttpConnectionParams;
    import org.apache.http.params.HttpParams;
    import org.apache.http.params.HttpProtocolParams;
    import org.apache.http.protocol.HTTP;

    import android.util.Log;

    public class CRunGetThread extends Thread
    {
        public DefaultHttpClient client;
        public HttpRequestBase request;

        String text;
        volatile Boolean finished;
        String Password;
        String Username;
        String Hosts;
        int    Ports;
        String Header;
        int    Timeout;
        boolean isHttps = false;

        int nError;

        public CRunGetThread()
        {
            text = "";
            finished = false;
        }

        public DefaultHttpClient mmfHttpClient() {

            try {
                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
                trustStore.load(null, null);

                SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
                sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

                HttpParams params = new BasicHttpParams();
                HttpConnectionParams.setSoTimeout(params, Timeout);
                HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
                HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

                SchemeRegistry registry = new SchemeRegistry();
                registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
                registry.register(new Scheme("https", sf, 443));

                ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

                return new DefaultHttpClient(ccm, params);

            } catch (Exception e) {
                return new DefaultHttpClient();
            }
        }


        @Override
        public void run()
        {
            try
            {
                nError = 0;

                HttpParams params = request.getParams();

                HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
                HttpProtocolParams.setUseExpectContinue(params, false);
                request.setParams(params);

                client = mmfHttpClient();

                if(Username != null && Password != null) {
                    UsernamePasswordCredentials creds = new UsernamePasswordCredentials(Username, Password);
                    request.addHeader(BasicScheme.authenticate(creds,"US-ASCII",false));
                }

                HttpResponse response = client.execute(request);
                StatusLine statusLine = response.getStatusLine();

                int statusCode = statusLine.getStatusCode();

                if (statusCode == 200) { // Status OK
                    HttpEntity entity = response.getEntity();

                    String charset = GetCharset(entity);

                    InputStreamReader reader;

                    if(charset !=null)
                        reader = new InputStreamReader(entity.getContent(), charset);
                    else
                        reader = new InputStreamReader(entity.getContent(), "UTF-8");

                    char [] buffer = new char [1024 * 32];
                    StringBuilder builder = new StringBuilder();

                    for (;;)
                    {
                        int length = reader.read (buffer);

                        if (length < 0)
                            break;

                        builder.append(buffer, 0, length);
                    }

                    text = builder.toString();
                    if(charset == null) {
                        if(text.contains("charset")) {
                            String textTmp = text;
                            String charsetName;
                            int count = textTmp.indexOf("charset=",1);
                            charsetName = textTmp.substring(textTmp.indexOf("=",count+1)+1, textTmp.indexOf(">", count+2));
                            charsetName = charsetName.replace(""", "");
                            charsetName = charsetName.replace("/", "");
                            charsetName = charsetName.replace(" ", "");
                            text = new String(textTmp.getBytes(), charsetName);
                        }
                    }
                }
                else {
                    text="";
                    nError = statusCode;
                }
                finished = true;
            }
            catch(Exception e)
            {
                Log.i("GET","Error: "+e.toString());
                text = "";
                finished = true;
            }
            finally
            {
                if (client != null && client.getConnectionManager() != null) {
                    client.getConnectionManager().shutdown();
                    client = null;
                }
                finished = true;
            }
        }

        public String GetCharset(HttpEntity entity) {
            String charset = null;
            if (entity.getContentType() != null) {
                HeaderElement values[] = entity.getContentType().getElements();
                if (values.length > 0) {
                    NameValuePair param = values[0].getParameterByName("charset");
                    if (param != null) {
                        charset = param.getValue();
                    }
                }
            }
            return charset;
        }
    }

    class MySSLSocketFactory extends SSLSocketFactory {
        SSLContext sslContext = SSLContext.getInstance("TLS");

        public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
            super(truststore);

            TrustManager tm = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };

            sslContext.init(null, new TrustManager[] { tm }, null);
        }

        @Override
        public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
            return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
        }

        @Override
        public Socket createSocket() throws IOException {
            return sslContext.getSocketFactory().createSocket();
        }
    }

package Extensions;

import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;

import Actions.CActExtension;
import Conditions.CCndExtension;
import Expressions.CValue;
import RunLoop.CCreateObjectInfo;
import Services.CBinaryFile;


public class CRunGet extends CRunExtension
{
    private Boolean usePost;

    private CRunGetThread thread;
    private String response;
    private String sURL;
    private URL mURL;
    private String mHeader="";
    private String mUser="";
    private String mPassword="";
    private String mUserAgent="";
    private int Timeout;

    private int nError;

    private ArrayList<NameValuePair> postData;

    @Override public int getNumberOfConditions()
    {
        return 3;
    }

    @Override
    public boolean createRunObject(CBinaryFile file, CCreateObjectInfo cob, int version)
    {
        usePost = false;
        postData = new ArrayList<NameValuePair>();

        return true;
    }

    @Override
    public void destroyRunObject(boolean bFast)
    {
        if(thread != null)
             thread = null;
    }

    @Override
    public int handleRunObject()
    {
        if(thread != null)
        {
            if(thread.finished)
            {
                response = thread.text;

                ho.generateEvent(0, 0);
                thread = null;
            }
        }

        return 0;
    }

    @Override
    public boolean condition(int num, CCndExtension cnd)
    {
        switch (num)
        {
            case 0:
                return true;

            case 1:
                return thread != null;

            case 2:
                return true;
        }

        return false;
    }

    @Override
    public void action(int num, CActExtension act)
    {
        switch (num)
        {
            case 0:

                if(thread != null)
                    return;

                try
                {
                    thread = new CRunGetThread();

                    sURL = act.getParamExpString(rh, 0);
                    mURL = new URL(sURL);

                    thread.Hosts = mURL.getHost();
                    thread.Ports = mURL.getPort();

                    if(mURL.getUserInfo() != null){
                        String UserInfo = mURL.getUserInfo();
                        String Login[] = UserInfo.split(":");
                        thread.Username = Login[0];
                        thread.Password = Login[1];
                        mURL = new URL (mURL.getProtocol(), mURL.getHost(), mURL.getPort(), mURL.getFile());
                    }
                    else if(mUser.length()>0){
                        thread.Username = mUser;
                        if(mPassword.length()>0)
                            thread.Password = mPassword;
                        else
                            thread.Password = null;
                    }
                    else {
                        thread.Username = null;
                        thread.Password = null;
                    }

                    // Verify for what type of protocol it is
                    if(mURL.getProtocol().toLowerCase().equals("https"))
                        thread.isHttps = true;
                    else
                        thread.isHttps = false;

                    thread.Timeout = Timeout;

                    if(usePost)
                    {

                        HttpPost post = new HttpPost(mURL.toString());

                        if(mUserAgent.length()==0)
                            post.addHeader("user-agent",  "Chrome");
                        else
                            post.addHeader("user-agent",  mUserAgent);

                        post.addHeader("Content-Type", "application/x-www-form-urlencoded");


                        if(mHeader.length() > 0) {
                            String lines[] = mHeader.split("[\r\n]+");
                            for (int i=0; i < lines.length; i++) {
                                String fields[] = lines[i].split(":");
                                post.addHeader(fields[0].trim(), fields[1].trim());
                            }
                        }


                        try
                        {
                            post.setEntity(new UrlEncodedFormEntity(postData));
                        }
                        catch(Exception e)
                        {
                            response = "";
                            nError = -1;
                            ho.generateEvent(0, 0);
                            thread.finished = true;
                            return;
                        }

                        thread.request = post;
                        thread.start();

                        usePost = false;
                        postData = new ArrayList<NameValuePair>();
                    }
                    else
                    {
                        HttpGet get = new HttpGet(mURL.toString());

                        thread.request = get;
                        thread.start();
                   }
                }
                catch(RuntimeException e)
                {
                    response = "";
                    nError=-1;
                    ho.generateEvent(0, 0);
                    thread.finished = true;
                    return;

                } catch (MalformedURLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }

                break;

            case 1:

                usePost = true;

                final String name = act.getParamExpString(rh, 0);
                final String value = act.getParamExpString(rh, 1);

                postData.add(new NameValuePair()
                {
                    @Override
                    public String getName()
                    {
                        return name;
                    }

                    @Override
                    public String getValue()
                    {
                        return value;
                    }
                });

                break;

            case 2:                 // Custom Header
                mHeader = act.getParamExpString(rh, 0);
                break;
            case 3:                 // Set User
                mUser = act.getParamExpString(rh, 0);
                break;
            case 4:                 // Set password
                mPassword = act.getParamExpString(rh, 0);
                break;
            case 5:                 // Set Timeout
                Timeout = act.getParamExpression(rh, 0);
                break;
            case 6:                 // Set User-Agent
                mUserAgent = act.getParamExpString(rh, 0);
                break;

        }
    }

    @Override
    public CValue expression(int num)
    {
        switch (num)
        {
            case 0:
                return new CValue(response);

            case 1:
                return new CValue(java.net.URLEncoder.encode(ho.getExpParam().getString()));

            case 2:
                return new CValue(nError);
        }

        return new CValue(0);
    }

}