private void BuildCookieCollectionFromDomainMatches(Uri uri, bool isSecure, int port, CookieCollection cookies, List <string> domainAttribute, bool matchOnlyPlainCookie)
{
for (int i = 0; i < domainAttribute.Count; i++)
{
bool found = false;
bool defaultAdded = false;
PathList pathList;
lock (m_domainTable.SyncRoot) {
pathList = (PathList)m_domainTable[domainAttribute[i]];
}
if (pathList == null)
{
continue;
}
lock (pathList.SyncRoot) {
foreach (DictionaryEntry entry in pathList)
{
string path = (string)entry.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path)))
{
found = true;
CookieCollection cc = (CookieCollection)entry.Value;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, matchOnlyPlainCookie);
if (path == "/")
{
defaultAdded = true;
}
}
else if (found)
{
break;
}
}
}
if (!defaultAdded)
{
CookieCollection cc = (CookieCollection)pathList["/"];
if (cc != null)
{
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, matchOnlyPlainCookie);
}
}
// Remove unused domain
// (This is the only place that does domain removal)
if (pathList.Count == 0)
{
AddRemoveDomain(domainAttribute[i], null);
}
}
}
private void BuildCookieCollectionFromDomainMatches(Uri uri, bool isSecure, int port, ref CookieCollection cookies, System.Collections.Generic.List <string> domainAttribute, bool matchOnlyPlainCookie)
{
for (int i = 0; i < domainAttribute.Count; i++)
{
PathList pathList;
lock (m_domainTable.SyncRoot)
{
pathList = (PathList)m_domainTable[domainAttribute[i]];
if (pathList == null)
{
continue;
}
}
lock (pathList.SyncRoot)
{
// Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
IDictionaryEnumerator e = pathList.GetEnumerator();
while (e.MoveNext())
{
string path = (string)e.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path)))
{
CookieCollection cc = (CookieCollection)e.Value;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(ref cookies, cc, port, isSecure, matchOnlyPlainCookie);
}
}
}
// Remove unused domain
// (This is the only place that does domain removal)
if (pathList.Count == 0)
{
lock (m_domainTable.SyncRoot)
{
m_domainTable.Remove(domainAttribute[i]);
}
}
}
}
private void BuildCookieCollectionFromDomainMatches(Uri uri, bool isSecure, int port, ref CookieCollection?cookies, System.Collections.Generic.List <string> domainAttribute, bool matchOnlyPlainCookie)
{
for (int i = 0; i < domainAttribute.Count; i++)
{
PathList pathList;
lock (m_domainTable.SyncRoot)
{
pathList = (PathList)m_domainTable[domainAttribute[i]] !;
if (pathList == null)
{
continue;
}
}
lock (pathList.SyncRoot)
{
SortedList list = pathList.List;
int listCount = list.Count;
for (int e = 0; e < listCount; e++)
{
string path = (string)list.GetKey(e);
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path), StringComparison.Ordinal))
{
CookieCollection cc = (CookieCollection)list.GetByIndex(e) !;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(ref cookies, cc, port, isSecure, matchOnlyPlainCookie);
}
}
}
// Remove unused domain.
if (pathList.Count == 0)
{
lock (m_domainTable.SyncRoot)
{
m_domainTable.Remove(domainAttribute[i]);
}
}
}
}
private void BuildCookieCollectionFromDomainMatches(Uri uri, bool isSecure, int port, ref CookieCollection cookies, List <string> domainAttribute, bool matchOnlyPlainCookie)
{
for (int i = 0; i < domainAttribute.Count; i++)
{
bool found = false;
bool defaultAdded = false;
PathList pathList;
lock (m_domainTable)
{
if (!m_domainTable.TryGetValue(domainAttribute[i], out pathList))
{
continue;
}
}
lock (pathList.SyncRoot)
{
foreach (KeyValuePair <string, CookieCollection> pair in pathList)
{
string path = pair.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path)))
{
found = true;
CookieCollection cc = pair.Value;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(ref cookies, cc, port, isSecure, matchOnlyPlainCookie);
if (path == "/")
{
defaultAdded = true;
}
}
else if (found)
{
break;
}
}
}
if (!defaultAdded)
{
CookieCollection cc = pathList["/"];
if (cc != null)
{
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(ref cookies, cc, port, isSecure, matchOnlyPlainCookie);
}
}
// Remove unused domain
// (This is the only place that does domain removal)
if (pathList.Count == 0)
{
lock (m_domainTable)
{
m_domainTable.Remove(domainAttribute[i]);
}
}
}
}
// This function, when called, must delete at least one cookie.
// If there are expired cookies in given scope they are cleaned up.
// If nothing is found the least used Collection will be found and removed
// from the container.
//
// Also note that expired cookies are also removed during request preparation
// (this.GetCookies method).
//
// Param. 'domain' == null means to age in the whole container.
private bool AgeCookies(string domain)
{
Debug.Assert(m_maxCookies != 0);
Debug.Assert(m_maxCookiesPerDomain != 0);
int removed = 0;
DateTime oldUsed = DateTime.MaxValue;
DateTime tempUsed;
CookieCollection lruCc = null;
string lruDomain = null;
string tempDomain = null;
PathList pathList;
int domain_count = 0;
int itemp = 0;
float remainingFraction = 1.0F;
// The container was shrunk, might need additional cleanup for each domain
if (m_count > m_maxCookies)
{
// Means the fraction of the container to be left.
// Each domain will be cut accordingly.
remainingFraction = (float)m_maxCookies / (float)m_count;
}
lock (m_domainTable)
{
foreach (KeyValuePair <string, PathList> entry in m_domainTable)
{
if (domain == null)
{
tempDomain = entry.Key;
pathList = entry.Value; // Aliasing to trick foreach
}
else
{
tempDomain = domain;
m_domainTable.TryGetValue(domain, out pathList);
}
domain_count = 0; // Cookies in the domain
lock (pathList.SyncRoot)
{
foreach (KeyValuePair <string, CookieCollection> pair in pathList)
{
CookieCollection cc = pair.Value;
itemp = ExpireCollection(cc);
removed += itemp;
m_count -= itemp; // Update this container's count
domain_count += cc.Count;
// We also find the least used cookie collection in ENTIRE container.
// We count the collection as LRU only if it holds 1+ elements.
if (cc.Count > 0 && (tempUsed = cc.TimeStamp(CookieCollection.Stamp.Check)) < oldUsed)
{
lruDomain = tempDomain;
lruCc = cc;
oldUsed = tempUsed;
}
}
}
// Check if we have reduced to the limit of the domain by expiration only.
int min_count = Math.Min((int)(domain_count * remainingFraction), Math.Min(m_maxCookiesPerDomain, m_maxCookies) - 1);
if (domain_count > min_count)
{
// This case requires sorting all domain collections by timestamp.
KeyValuePair <DateTime, CookieCollection>[] cookies;
lock (pathList.SyncRoot)
{
cookies = new KeyValuePair <DateTime, CookieCollection> [pathList.Count];
foreach (KeyValuePair <string, CookieCollection> pair in pathList)
{
CookieCollection cc = pair.Value;
cookies[itemp] = new KeyValuePair <DateTime, CookieCollection>(cc.TimeStamp(CookieCollection.Stamp.Check), cc);
++itemp;
}
}
Array.Sort(cookies, (a, b) => a.Key.CompareTo(b.Key));
itemp = 0;
for (int i = 0; i < cookies.Length; ++i)
{
CookieCollection cc = cookies[i].Value;
lock (cc)
{
while (domain_count > min_count && cc.Count > 0)
{
cc.RemoveAt(0);
--domain_count;
--m_count;
++removed;
}
}
if (domain_count <= min_count)
{
break;
}
}
if (domain_count > min_count && domain != null)
{
// Cannot complete aging of explicit domain (no cookie adding allowed).
return(false);
}
}
}
}
// We have completed aging of the specified domain.
if (domain != null)
{
return(true);
}
// The rest is for entire container aging.
// We must get at least one free slot.
// Don't need to apply LRU if we already cleaned something.
if (removed != 0)
{
return(true);
}
if (oldUsed == DateTime.MaxValue)
{
// Something strange. Either capacity is 0 or all collections are locked with cc.Used.
return(false);
}
// Remove oldest cookies from the least used collection.
lock (lruCc)
{
while (m_count >= m_maxCookies && lruCc.Count > 0)
{
lruCc.RemoveAt(0);
--m_count;
}
}
return(true);
}
internal CookieCollection InternalGetCookies(Uri uri)
{
bool isSecure = uri.Scheme == Uri.UriSchemeHttps;
int port = uri.Port;
CookieCollection destination = new CookieCollection();
ArrayList list = new ArrayList();
int num2 = 0;
string host = uri.Host;
int index = host.IndexOf('.');
if (index == -1)
{
list.Add(host);
list.Add("." + host);
if ((this.m_fqdnMyDomain != null) && (this.m_fqdnMyDomain.Length != 0))
{
list.Add(host + this.m_fqdnMyDomain);
list.Add(this.m_fqdnMyDomain);
num2 = 3;
}
else
{
num2 = 1;
}
}
else
{
list.Add(host);
list.Add("." + host);
list.Add(host.Substring(index));
num2 = 2;
if (host.Length > 2)
{
int num4 = host.LastIndexOf('.', host.Length - 2);
if (num4 > 0)
{
num4 = host.LastIndexOf('.', num4 - 1);
}
if (num4 != -1)
{
while ((index < num4) && ((index = host.IndexOf('.', index + 1)) != -1))
{
list.Add(host.Substring(index));
}
}
}
}
foreach (string str2 in list)
{
bool flag2 = false;
bool flag3 = false;
PathList list2 = (PathList)this.m_domainTable[str2];
num2--;
if (list2 != null)
{
foreach (DictionaryEntry entry in list2)
{
string key = (string)entry.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(key)))
{
flag2 = true;
CookieCollection source = (CookieCollection)entry.Value;
source.TimeStamp(CookieCollection.Stamp.Set);
this.MergeUpdateCollections(destination, source, port, isSecure, num2 < 0);
if (key == "/")
{
flag3 = true;
}
}
else if (flag2)
{
break;
}
}
if (!flag3)
{
CookieCollection cookies3 = (CookieCollection)list2["/"];
if (cookies3 != null)
{
cookies3.TimeStamp(CookieCollection.Stamp.Set);
this.MergeUpdateCollections(destination, cookies3, port, isSecure, num2 < 0);
}
}
if (list2.Count == 0)
{
this.AddRemoveDomain(str2, null);
}
}
}
return(destination);
}
internal CookieCollection InternalGetCookies(Uri uri)
{
bool isSecure = (uri.Scheme == Uri.UriSchemeHttps);
int port = uri.Port;
CookieCollection cookies = new CookieCollection();
ArrayList nameKeys = new ArrayList();
int firstCompatibleVersion0SpecKey = 0;
string fqdnRemote = uri.Host;
int dot = fqdnRemote.IndexOf('.');
if (dot == -1)
{
// DNS.resolve may return short names even for other inet domains ;-(
// We _don't_ know what the exact domain is, so try also grab short hostname cookies.
nameKeys.Add(fqdnRemote);
// grab long name from the local domain
nameKeys.Add(fqdnRemote + m_fqdnMyDomain);
// grab the local domain itself
nameKeys.Add(m_fqdnMyDomain);
firstCompatibleVersion0SpecKey = 3;
}
else
{
// grab the host itself
nameKeys.Add(fqdnRemote);
// grab the host domain
nameKeys.Add(fqdnRemote.Substring(dot));
firstCompatibleVersion0SpecKey = 2;
// The following block is only for compatibility with Version0 spec.
// Still, we'll add only Plain-Variant cookies if found under below keys
if (fqdnRemote.Length > 2)
{
// We ignore the '.' at the end on the name
int last = fqdnRemote.LastIndexOf('.', fqdnRemote.Length - 2);
//AND keys with <2 dots inside.
if (last > 0)
{
last = fqdnRemote.LastIndexOf('.', last - 1);
}
if (last != -1)
{
while ((dot < last) && (dot = fqdnRemote.IndexOf('.', dot + 1)) != -1)
{
nameKeys.Add(fqdnRemote.Substring(dot));
}
}
}
}
foreach (string key in nameKeys)
{
bool found = false;
bool defaultAdded = false;
PathList pathList = (PathList)m_domainTable[key];
--firstCompatibleVersion0SpecKey;
if (pathList == null)
{
continue;
}
foreach (DictionaryEntry entry in pathList)
{
string path = (string)entry.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path)))
{
found = true;
CookieCollection cc = (CookieCollection)entry.Value;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, (firstCompatibleVersion0SpecKey < 0));
if (path == "/")
{
defaultAdded = true;
}
}
else if (found)
{
break;
}
}
if (!defaultAdded)
{
CookieCollection cc = (CookieCollection)pathList["/"];
if (cc != null)
{
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, (firstCompatibleVersion0SpecKey < 0));
}
}
// Remove unused domain
// (This is the only place that does domain removal)
if (pathList.Count == 0)
{
AddRemoveDomain(key, null);
}
}
return(cookies);
}
internal CookieCollection InternalGetCookies(Uri uri)
{
bool isSecure = uri.Scheme == Uri.UriSchemeHttps;
int port = uri.Port;
CookieCollection destination = new CookieCollection();
ArrayList arrayList = new ArrayList();
string host = uri.Host;
int startIndex = host.IndexOf('.');
int num1;
if (startIndex == -1)
{
arrayList.Add((object)host);
arrayList.Add((object)("." + host));
if (this.m_fqdnMyDomain != null && this.m_fqdnMyDomain.Length != 0)
{
arrayList.Add((object)(host + this.m_fqdnMyDomain));
arrayList.Add((object)this.m_fqdnMyDomain);
num1 = 3;
}
else
{
num1 = 1;
}
}
else
{
arrayList.Add((object)host);
arrayList.Add((object)("." + host));
arrayList.Add((object)host.Substring(startIndex));
num1 = 2;
if (host.Length > 2)
{
int num2 = host.LastIndexOf('.', host.Length - 2);
if (num2 > 0)
{
num2 = host.LastIndexOf('.', num2 - 1);
}
if (num2 != -1)
{
while (startIndex < num2 && (startIndex = host.IndexOf('.', startIndex + 1)) != -1)
{
arrayList.Add((object)host.Substring(startIndex));
}
}
}
}
foreach (string key in arrayList)
{
bool flag1 = false;
bool flag2 = false;
PathList pathList = (PathList)this.m_domainTable[(object)key];
--num1;
if (pathList != null)
{
foreach (DictionaryEntry dictionaryEntry in pathList)
{
string str = (string)dictionaryEntry.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(str)))
{
flag1 = true;
CookieCollection source = (CookieCollection)dictionaryEntry.Value;
source.TimeStamp(CookieCollection.Stamp.Set);
this.MergeUpdateCollections(destination, source, port, isSecure, num1 < 0);
if (str == "/")
{
flag2 = true;
}
}
else if (flag1)
{
break;
}
}
if (!flag2)
{
CookieCollection source = (CookieCollection)pathList["/"];
if (source != null)
{
source.TimeStamp(CookieCollection.Stamp.Set);
this.MergeUpdateCollections(destination, source, port, isSecure, num1 < 0);
}
}
if (pathList.Count == 0)
{
this.AddRemoveDomain(key, (PathList)null);
}
}
}
return(destination);
}
