/** Tests explicit root path with a non-trivial URL fetch from the domain */
 public void testRootPath1() throws Exception {
   URL url = new URL("http://d.e.f/moo.html");
   man.addCookieFromHeader("test=moo;path=/", url);
   String s = man.getCookieHeaderForURL(new URL("http://d.e.f/goo.html"));
   assertNotNull(s);
   assertEquals("test=moo", s);
 }
 // Test session cookie is returned
 public void testSessionCookie() throws Exception {
   URL url = new URL("http://a.b.c/");
   man.addCookieFromHeader("test=1", url);
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test=1", s);
 }
 public void testCookies2() throws Exception {
   URL url = new URL("https://a.b.c.d/testCookies2");
   man.addCookieFromHeader("test1=1;secure, test2=2;secure", url);
   assertEquals(2, man.getCookieCount());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test1=1; test2=2", s);
 }
 // Test multi-cookie header handling
 public void testCookies1() throws Exception {
   URL url = new URL("http://a.b.c.d/testCookies1");
   man.addCookieFromHeader("test1=1; comment=\"how,now\", test2=2; version=1", url);
   assertEquals(2, man.getCookieCount());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test1=1; test2=2", s);
 }
 // Test New cookie is returned
 public void testNewCookie() throws Exception {
   URL url = new URL("http://a.b.c/");
   man.addCookieFromHeader("test=1; expires=Mon, 01-Jan-2990 00:00:00 GMT", url);
   assertEquals(1, man.getCookieCount());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test=1", s);
 }
 @Override
 public void setUp() throws Exception {
   super.setUp();
   jmctx = JMeterContextService.getContext();
   man = new CookieManager();
   man.setThreadContext(jmctx);
   man.testStarted(); // This is needed in order to set up the cookie policy
 }
 public void testSendCookie2() throws Exception {
   man.add(new Cookie("id", "value", ".apache.org", "/", false, 9999999999L));
   HTTPSamplerBase sampler = new HTTPNullSampler();
   sampler.setDomain("jakarta.apache.org");
   sampler.setPath("/index.html");
   sampler.setMethod(HTTPSamplerBase.GET);
   assertNotNull(man.getCookieHeaderForURL(sampler.getUrl()));
 }
 public void testCrossDomainHandling() throws Exception {
   URL url = new URL("http://jakarta.apache.org/");
   assertEquals(0, man.getCookieCount()); // starts empty
   man.addCookieFromHeader("test=2;domain=.hc.apache.org", url);
   assertEquals(0, man.getCookieCount()); // should not be stored
   man.addCookieFromHeader("test=1;domain=.jakarta.apache.org", url);
   assertEquals(1, man.getCookieCount()); // OK
 }
 // Bug 2063
 public void testCookieWithEquals() throws Exception {
   URL url = new URL("http://a.b.c/");
   man.addCookieFromHeader("NSCP_USER_LOGIN1_NEW=SHA=xxxxx", url);
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("NSCP_USER_LOGIN1_NEW=SHA=xxxxx", s);
   Cookie c = man.get(0);
   assertEquals("NSCP_USER_LOGIN1_NEW", c.getName());
   assertEquals("SHA=xxxxx", c.getValue());
 }
 public void testCookieOrdering1() throws Exception {
   URL url = new URL("http://order.now/sub1/moo.html");
   man.addCookieFromHeader("test1=moo1;path=/", url);
   man.addCookieFromHeader("test2=moo2;path=/sub1", url);
   man.addCookieFromHeader("test2=moo3;path=/", url);
   assertEquals(3, man.getCookieCount());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test2=moo2; test1=moo1; test2=moo3", s);
 }
  /**
   * Add the content related headers. These headers contain user private data and is not used when
   * we are proxying an untrusted request.
   */
  private void populateHeaders() {

    if (mReferrer != null) mHeaders.put("Referer", mReferrer);
    if (mContentType != null) mHeaders.put(CONTENT_TYPE, mContentType);

    // if we have an active proxy and have proxy credentials, do pre-emptive
    // authentication to avoid an extra round-trip:
    if (mNetwork.isValidProxySet()) {
      String username;
      String password;
      /* The proxy credentials can be set in the Network thread */
      synchronized (mNetwork) {
        username = mNetwork.getProxyUsername();
        password = mNetwork.getProxyPassword();
      }
      if (username != null && password != null) {
        // we collect credentials ONLY if the proxy scheme is BASIC!!!
        String proxyHeader = RequestHandle.authorizationHeader(true);
        mHeaders.put(
            proxyHeader, "Basic " + RequestHandle.computeBasicAuthResponse(username, password));
      }
    }

    // Set cookie header
    String cookie = CookieManager.getInstance().getCookie(mListener.getWebAddress());
    if (cookie != null && cookie.length() > 0) {
      mHeaders.put("Cookie", cookie);
    }
  }
 /**
  * Store a cookie string associated with a url.
  *
  * @param url The url to be used as a key for the cookie.
  * @param value The cookie string to be stored.
  */
 @DSComment("Private Method")
 @DSBan(DSCat.PRIVATE_METHOD)
 @DSGenerator(
     tool_name = "Doppelganger",
     tool_version = "2.0",
     generated_on = "2013-12-30 12:32:41.967 -0500",
     hash_original_method = "D5A9FC7DDB356B7F9D175C82B50A2AF1",
     hash_generated_method = "24C7574FF957618A543446AAAEE4BC4D")
 private void setCookies(String url, String value) {
   if (value.contains("\r") || value.contains("\n")) {
     // for security reason, filter out '\r' and '\n' from the cookie
     int size = value.length();
     StringBuilder buffer = new StringBuilder(size);
     int i = 0;
     while (i != -1 && i < size) {
       int ir = value.indexOf('\r', i);
       int in = value.indexOf('\n', i);
       int newi = (ir == -1) ? in : (in == -1 ? ir : (ir < in ? ir : in));
       if (newi > i) {
         buffer.append(value.subSequence(i, newi));
       } else if (newi == -1) {
         buffer.append(value.subSequence(i, size));
         break;
       }
       i = newi + 1;
     }
     value = buffer.toString();
   }
   CookieManager.getInstance().setCookie(url, value);
 }
Esempio n. 13
0
 private void syncFromRamToFlash(ArrayList<Cookie> list) {
   Iterator<Cookie> iter = list.iterator();
   while (iter.hasNext()) {
     Cookie cookie = iter.next();
     if (cookie.mode != Cookie.MODE_NORMAL) {
       if (cookie.mode != Cookie.MODE_NEW) {
         mDataBase.deleteCookies(cookie.domain, cookie.path, cookie.name);
       }
       if (cookie.mode != Cookie.MODE_DELETED) {
         mDataBase.addCookie(cookie);
         CookieManager.getInstance().syncedACookie(cookie);
       } else {
         CookieManager.getInstance().deleteACookie(cookie);
       }
     }
   }
 }
 public void testRemoveCookie() throws Exception {
   man.setThreadContext(jmctx);
   Cookie c = new Cookie("id", "me", "127.0.0.1", "/", false, 0);
   man.add(c);
   assertEquals(1, man.getCookieCount());
   // This should be ignored, as there is no value
   Cookie d = new Cookie("id", "", "127.0.0.1", "/", false, 0);
   man.add(d);
   assertEquals(0, man.getCookieCount());
   man.add(c);
   man.add(c);
   assertEquals(1, man.getCookieCount());
   Cookie e = new Cookie("id", "me2", "127.0.0.1", "/", false, 0);
   man.add(e);
   assertEquals(1, man.getCookieCount());
 }
 /** Returns whether cookies are enabled or not. */
 @DSComment("Private Method")
 @DSBan(DSCat.PRIVATE_METHOD)
 @DSGenerator(
     tool_name = "Doppelganger",
     tool_version = "2.0",
     generated_on = "2013-12-30 12:32:41.972 -0500",
     hash_original_method = "E9376C130584FE2146C1CFB7A84FB471",
     hash_generated_method = "FA6BBF0A4D9665939C38DB115FB61EFF")
 private boolean cookiesEnabled() {
   return CookieManager.getInstance().acceptCookie();
 }
 /**
  * Retrieve the cookie string for the given url.
  *
  * @param url The resource's url.
  * @return A String representing the cookies for the given resource url.
  */
 @DSComment("Private Method")
 @DSBan(DSCat.PRIVATE_METHOD)
 @DSGenerator(
     tool_name = "Doppelganger",
     tool_version = "2.0",
     generated_on = "2013-12-30 12:32:41.970 -0500",
     hash_original_method = "E3D7D6931554145E868760CB2C4A26A3",
     hash_generated_method = "EE86FFF77F12F6E87C0C4F0204A00383")
 private String cookies(String url) {
   return CookieManager.getInstance().getCookie(url);
 }
Esempio n. 17
0
  protected void syncFromRamToFlash() {
    if (DebugFlags.COOKIE_SYNC_MANAGER) {
      Log.v(LOGTAG, "CookieSyncManager::syncFromRamToFlash STARTS");
    }

    if (!CookieManager.getInstance().acceptCookie()) {
      return;
    }

    ArrayList<Cookie> cookieList = CookieManager.getInstance().getUpdatedCookiesSince(mLastUpdate);
    mLastUpdate = System.currentTimeMillis();
    syncFromRamToFlash(cookieList);

    ArrayList<Cookie> lruList = CookieManager.getInstance().deleteLRUDomain();
    syncFromRamToFlash(lruList);

    if (DebugFlags.COOKIE_SYNC_MANAGER) {
      Log.v(LOGTAG, "CookieSyncManager::syncFromRamToFlash DONE");
    }
  }
Esempio n. 18
0
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.oauthactivity_layout);
    ActionBar actionBar = getActionBar();
    actionBar.setDisplayHomeAsUpEnabled(false);
    actionBar.setTitle(getString(R.string.login));
    webView = (WebView) findViewById(R.id.webView);
    webView.setWebViewClient(new WeiboWebViewClient());

    WebSettings settings = webView.getSettings();
    settings.setJavaScriptEnabled(true);
    settings.setSaveFormData(false);
    settings.setSavePassword(false);
    settings.setCacheMode(WebSettings.LOAD_NO_CACHE);
    settings.setRenderPriority(WebSettings.RenderPriority.HIGH);

    CookieSyncManager.createInstance(this);
    CookieManager cookieManager = CookieManager.getInstance();
    cookieManager.removeAllCookie();
  }
 public void testCookiePolicyNetscape() throws Exception {
   man.setCookiePolicy(CookiePolicy.NETSCAPE);
   man.testStarted(); // ensure policy is picked up
   URL url = new URL("http://www.order.now/sub1/moo.html");
   man.addCookieFromHeader("test1=moo1;", url);
   man.addCookieFromHeader("test2=moo2;path=/sub1", url);
   man.addCookieFromHeader("test2=moo3;path=/", url);
   assertEquals(3, man.getCookieCount());
   assertEquals("/sub1", man.get(0).getPath());
   assertEquals("/sub1", man.get(1).getPath());
   assertEquals("/", man.get(2).getPath());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   org.apache.commons.httpclient.Cookie[] c = man.getCookiesForUrl(url);
   assertEquals("/sub1", c[0].getPath());
   assertFalse(c[0].isPathAttributeSpecified());
   assertEquals("/sub1", c[1].getPath());
   assertTrue(c[1].isPathAttributeSpecified());
   assertEquals("/", c[2].getPath());
   assertTrue(c[2].isPathAttributeSpecified());
   assertEquals("test1=moo1; test2=moo2; test2=moo3", s);
 }
 public void testCookieOrdering2() throws Exception {
   URL url = new URL("http://order.now/sub1/moo.html");
   man.addCookieFromHeader("test1=moo1;", url);
   man.addCookieFromHeader("test2=moo2;path=/sub1", url);
   man.addCookieFromHeader("test2=moo3;path=/", url);
   assertEquals(3, man.getCookieCount());
   assertEquals("/sub1", man.get(0).getPath()); // Defaults to caller URL
   assertEquals("/sub1", man.get(1).getPath());
   assertEquals("/", man.get(2).getPath());
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   org.apache.commons.httpclient.Cookie[] c = man.getCookiesForUrl(url);
   assertEquals("/sub1", c[0].getPath());
   assertFalse(c[0].isPathAttributeSpecified());
   assertEquals("/sub1", c[1].getPath());
   assertTrue(c[1].isPathAttributeSpecified());
   assertEquals("/", c[2].getPath());
   assertEquals("test1=moo1; test2=moo2; test2=moo3", s);
 }
 public void testDuplicateCookie2() throws Exception {
   URL url = new URL("http://a.b.c/");
   man.addCookieFromHeader("test=1", url);
   man.addCookieFromHeader("test2=a", url);
   String s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test=1; test2=a", s); // Assumes some kind of list is used
   man.addCookieFromHeader("test=2", url);
   man.addCookieFromHeader("test3=b", url);
   s = man.getCookieHeaderForURL(url);
   assertNotNull(s);
   assertEquals("test2=a; test=2; test3=b", s); // Assumes some kind of list is use
   // If not using a list that retains the order, then the asserts would need to change
 }
  // Test cookie matching
  public void testCookieMatching() throws Exception {
    URL url = new URL("http://a.b.c:8080/TopDir/fred.jsp");
    man.addCookieFromHeader("ID=abcd; Path=/TopDir", url);
    String s = man.getCookieHeaderForURL(url);
    assertNotNull(s);
    assertEquals("ID=abcd", s);

    url = new URL("http://a.b.c:8080/other.jsp");
    s = man.getCookieHeaderForURL(url);
    assertNull(s);

    url = new URL("http://a.b.c:8080/TopDir/suub/another.jsp");
    s = man.getCookieHeaderForURL(url);
    assertNotNull(s);

    url = new URL("http://a.b.c:8080/TopDir");
    s = man.getCookieHeaderForURL(url);
    assertNotNull(s);

    url = new URL("http://a.b.d/");
    s = man.getCookieHeaderForURL(url);
    assertNull(s);
  }
 /**
  * Test that we won't be tricked by similar host names (this was a past bug, although it never got
  * reported in the bug database):
  */
 public void testSimilarHostNames() throws Exception {
   URL url = new URL("http://ache.org/");
   man.addCookieFromHeader("test=1", url);
   url = new URL("http://jakarta.apache.org/");
   assertNull(man.getCookieHeaderForURL(url));
 }
  /**
   * Parse the headers sent from the server.
   *
   * @param headers gives up the HeaderGroup IMPORTANT: as this is called from network thread, can't
   *     call native directly
   */
  public void headers(Headers headers) {
    if (Config.LOGV) Log.v(LOGTAG, "LoadListener.headers");
    if (mCancelled) return;
    mHeaders = headers;
    mMimeType = "";
    mEncoding = "";

    ArrayList<String> cookies = headers.getSetCookie();
    for (int i = 0; i < cookies.size(); ++i) {
      CookieManager.getInstance().setCookie(mUri, cookies.get(i));
    }

    long contentLength = headers.getContentLength();
    if (contentLength != Headers.NO_CONTENT_LENGTH) {
      mContentLength = contentLength;
    } else {
      mContentLength = 0;
    }

    String contentType = headers.getContentType();
    if (contentType != null) {
      parseContentTypeHeader(contentType);

      // If we have one of "generic" MIME types, try to deduce
      // the right MIME type from the file extension (if any):
      if (mMimeType.equalsIgnoreCase("text/plain")
          || mMimeType.equalsIgnoreCase("application/octet-stream")) {

        String newMimeType = guessMimeTypeFromExtension();
        if (newMimeType != null) {
          mMimeType = newMimeType;
        }
      } else if (mMimeType.equalsIgnoreCase("text/vnd.wap.wml")) {
        // As we don't support wml, render it as plain text
        mMimeType = "text/plain";
      } else {
        // XXX: Until the servers send us either correct xhtml or
        // text/html, treat application/xhtml+xml as text/html.
        // It seems that xhtml+xml and vnd.wap.xhtml+xml mime
        // subtypes are used interchangeably. So treat them the same.
        if (mMimeType.equalsIgnoreCase("application/xhtml+xml")
            || mMimeType.equals("application/vnd.wap.xhtml+xml")) {
          mMimeType = "text/html";
        }
      }
    } else {
      /* Often when servers respond with 304 Not Modified or a
      Redirect, then they don't specify a MIMEType. When this
      occurs, the function below is called.  In the case of
      304 Not Modified, the cached headers are used rather
      than the headers that are returned from the server. */
      guessMimeType();
    }

    // is it an authentication request?
    boolean mustAuthenticate = (mStatusCode == HTTP_AUTH || mStatusCode == HTTP_PROXY_AUTH);
    // is it a proxy authentication request?
    boolean isProxyAuthRequest = (mStatusCode == HTTP_PROXY_AUTH);
    // is this authentication request due to a failed attempt to
    // authenticate ealier?
    mAuthFailed = false;

    // if we tried to authenticate ourselves last time
    if (mAuthHeader != null) {
      // we failed, if we must to authenticate again now and
      // we have a proxy-ness match
      mAuthFailed = (mustAuthenticate && isProxyAuthRequest == mAuthHeader.isProxy());

      // if we did NOT fail and last authentication request was a
      // proxy-authentication request
      if (!mAuthFailed && mAuthHeader.isProxy()) {
        Network network = Network.getInstance(mContext);
        // if we have a valid proxy set
        if (network.isValidProxySet()) {
          /* The proxy credentials can be read in the WebCore thread
           */
          synchronized (network) {
            // save authentication credentials for pre-emptive proxy
            // authentication
            network.setProxyUsername(mAuthHeader.getUsername());
            network.setProxyPassword(mAuthHeader.getPassword());
          }
        }
      }
    }
    // it is only here that we can reset the last mAuthHeader object
    // (if existed) and start a new one!!!
    mAuthHeader = null;
    if (mustAuthenticate) {
      if (mStatusCode == HTTP_AUTH) {
        mAuthHeader = parseAuthHeader(headers.getWwwAuthenticate());
      } else {
        mAuthHeader = parseAuthHeader(headers.getProxyAuthenticate());
        // if successfully parsed the header
        if (mAuthHeader != null) {
          // mark the auth-header object as a proxy
          mAuthHeader.setProxy();
        }
      }
    }

    // Only create a cache file if the server has responded positively.
    if ((mStatusCode == HTTP_OK
            || mStatusCode == HTTP_FOUND
            || mStatusCode == HTTP_MOVED_PERMANENTLY
            || mStatusCode == HTTP_TEMPORARY_REDIRECT)
        && mNativeLoader != 0) {
      // Content arriving from a StreamLoader (eg File, Cache or Data)
      // will not be cached as they have the header:
      // cache-control: no-store
      mCacheResult = CacheManager.createCacheFile(mUrl, mStatusCode, headers, mMimeType, false);
      if (mCacheResult != null) {
        mCacheResult.encoding = mEncoding;
      }
    }
    sendMessageInternal(obtainMessage(MSG_CONTENT_HEADERS));
  }
 // Test Old cookie is not returned
 public void testOldCookie() throws Exception {
   URL url = new URL("http://a.b.c/");
   man.addCookieFromHeader("test=1; expires=Mon, 01-Jan-1990 00:00:00 GMT", url);
   String s = man.getCookieHeaderForURL(url);
   assertNull(s);
 }
 /**
  * Test that the cookie domain field is actually handled as browsers do (i.e.: host X matches
  * domain .X):
  */
 public void testDomainHandling() throws Exception {
   URL url = new URL("http://jakarta.apache.org/");
   man.addCookieFromHeader("test=1;domain=.jakarta.apache.org", url);
   assertNotNull(man.getCookieHeaderForURL(url));
 }
  public void testLoad() throws Exception {
    assertEquals(0, man.getCookieCount());
    man.addFile(findTestPath("testfiles/cookies.txt"));
    assertEquals(3, man.getCookieCount());

    int num = 0;
    assertEquals("name", man.get(num).getName());
    assertEquals("value", man.get(num).getValue());
    assertEquals("path", man.get(num).getPath());
    assertEquals("domain", man.get(num).getDomain());
    assertTrue(man.get(num).getSecure());
    assertEquals(num, man.get(num).getExpires());

    num++;
    assertEquals("name2", man.get(num).getName());
    assertEquals("value2", man.get(num).getValue());
    assertEquals("/", man.get(num).getPath());
    assertEquals("", man.get(num).getDomain());
    assertFalse(man.get(num).getSecure());
    assertEquals(0, man.get(num).getExpires());

    num++;
    assertEquals("a", man.get(num).getName());
    assertEquals("b", man.get(num).getValue());
    assertEquals("d", man.get(num).getPath());
    assertEquals("c", man.get(num).getDomain());
    assertTrue(man.get(num).getSecure());
    assertEquals(0, man.get(num).getExpires()); // Show that maxlong now saved as 0
  }
 public void testCookiePolicyIgnore() throws Exception {
   man.setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
   man.testStarted(); // ensure policy is picked up
   URL url = new URL("http://order.now/sub1/moo.html");
   man.addCookieFromHeader("test1=moo1;", url);
   man.addCookieFromHeader("test2=moo2;path=/sub1", url);
   man.addCookieFromHeader("test2=moo3;path=/", url);
   assertEquals(0, man.getCookieCount()); // Cookies are ignored
   Cookie cc;
   cc = new Cookie("test1", "moo1", null, "/sub1", false, 0, false, false);
   man.add(cc);
   cc = new Cookie("test2", "moo2", null, "/sub1", false, 0, true, false);
   man.add(cc);
   cc = new Cookie("test3", "moo3", null, "/", false, 0, false, false);
   man.add(cc);
   assertEquals(3, man.getCookieCount());
   assertEquals("/sub1", man.get(0).getPath());
   assertEquals("/sub1", man.get(1).getPath());
   assertEquals("/", man.get(2).getPath());
   String s = man.getCookieHeaderForURL(url);
   assertNull(s);
   org.apache.commons.httpclient.Cookie[] c = man.getCookiesForUrl(url);
   assertEquals(0, c.length); // Cookies again ignored
 }