fileFormatVersion: 2

guid: 512b1983a304140809456c78f4e3b1b7

folderAsset: yes

DefaultImporter:

  userData: 

ref: refs/heads/master

[core]

	repositoryformatversion = 0

	filemode = true

	bare = false

	logallrefupdates = true

	ignorecase = true

	precomposeunicode = true

[remote "origin"]

	url = https://github.com/andyburke/UnityHTTP.git

	fetch = +refs/heads/*:refs/remotes/origin/*

[branch "master"]

	remote = origin

	merge = refs/heads/master

Unnamed repository; edit this file 'description' to name the repository.

#!/bin/sh

#

# An example hook script to check the commit log message taken by

# applypatch from an e-mail message.

#

# The hook should exit with non-zero status after issuing an

# appropriate message if it wants to stop the commit.  The hook is

# allowed to edit the commit message file.

#

# To enable this hook, rename this file to "applypatch-msg".

. git-sh-setup

test -x "$GIT_DIR/hooks/commit-msg" &&

	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}

:

#!/bin/sh

#

# An example hook script to check the commit log message.

# Called by "git commit" with one argument, the name of the file

# that has the commit message.  The hook should exit with non-zero

# status after issuing an appropriate message if it wants to stop the

# commit.  The hook is allowed to edit the commit message file.

#

# To enable this hook, rename this file to "commit-msg".

# Uncomment the below to add a Signed-off-by line to the message.

# Doing this in a hook is a bad idea in general, but the prepare-commit-msg

# hook is more suited to it.

#

# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')

# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

# This example catches duplicate Signed-off-by lines.

test "" = "$(grep '^Signed-off-by: ' "$1" |

	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {

	echo >&2 Duplicate Signed-off-by lines.

	exit 1

}

#!/bin/sh

#

# An example hook script to prepare a packed repository for use over

# dumb transports.

#

# To enable this hook, rename this file to "post-update".

exec git update-server-info

#!/bin/sh

#

# An example hook script to verify what is about to be committed

# by applypatch from an e-mail message.

#

# The hook should exit with non-zero status after issuing an

# appropriate message if it wants to stop the commit.

#

# To enable this hook, rename this file to "pre-applypatch".

. git-sh-setup

test -x "$GIT_DIR/hooks/pre-commit" &&

	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}

:

#!/bin/sh

#

# An example hook script to verify what is about to be committed.

# Called by "git commit" with no arguments.  The hook should

# exit with non-zero status after issuing an appropriate message if

# it wants to stop the commit.

#

# To enable this hook, rename this file to "pre-commit".

if git rev-parse --verify HEAD >/dev/null 2>&1

then

	against=HEAD

else

	# Initial commit: diff against an empty tree object

	against=4b825dc642cb6eb9a060e54bf8d69288fbee4904

fi

# If you want to allow non-ASCII filenames set this variable to true.

allownonascii=$(git config --bool hooks.allownonascii)

# Redirect output to stderr.

exec 1>&2

# Cross platform projects tend to avoid non-ASCII filenames; prevent

# them from being added to the repository. We exploit the fact that the

# printable range starts at the space character and ends with tilde.

if [ "$allownonascii" != "true" ] &&

	# Note that the use of brackets around a tr range is ok here, (it's

	# even required, for portability to Solaris 10's /usr/bin/tr), since

	# the square bracket bytes happen to fall in the designated range.

	test $(git diff --cached --name-only --diff-filter=A -z $against |

	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0

then

	cat <<\EOF

Error: Attempt to add a non-ASCII file name.

This can cause problems if you want to work with people on other platforms.

To be portable it is advisable to rename the file.

If you know what you are doing you can disable this check using:

  git config hooks.allownonascii true

EOF

	exit 1

fi

# If there are whitespace errors, print the offending file names and fail.

exec git diff-index --check --cached $against --

#!/bin/sh

# An example hook script to verify what is about to be pushed.  Called by "git

# push" after it has checked the remote status, but before anything has been

# pushed.  If this script exits with a non-zero status nothing will be pushed.

#

# This hook is called with the following parameters:

#

# $1 -- Name of the remote to which the push is being done

# $2 -- URL to which the push is being done

#

# If pushing without using a named remote those arguments will be equal.

#

# Information about the commits which are being pushed is supplied as lines to

# the standard input in the form:

#

#   <local ref> <local sha1> <remote ref> <remote sha1>

#

# This sample shows how to prevent push of commits where the log message starts

# with "WIP" (work in progress).

remote="$1"

url="$2"

z40=0000000000000000000000000000000000000000

IFS=' '

while read local_ref local_sha remote_ref remote_sha

do

	if [ "$local_sha" = $z40 ]

	then

		# Handle delete

		:

	else

		if [ "$remote_sha" = $z40 ]

		then

			# New branch, examine all commits

			range="$local_sha"

		else

			# Update to existing branch, examine new commits

			range="$remote_sha..$local_sha"

		fi

		# Check for WIP commit

		commit=`git rev-list -n 1 --grep '^WIP' "$range"`

		if [ -n "$commit" ]

		then

			echo "Found WIP commit in $local_ref, not pushing"

			exit 1

		fi

	fi

done

exit 0

#!/bin/sh

#

# Copyright (c) 2006, 2008 Junio C Hamano

#

# The "pre-rebase" hook is run just before "git rebase" starts doing

# its job, and can prevent the command from running by exiting with

# non-zero status.

#

# The hook is called with the following parameters:

#

# $1 -- the upstream the series was forked from.

# $2 -- the branch being rebased (or empty when rebasing the current branch).

#

# This sample shows how to prevent topic branches that are already

# merged to 'next' branch from getting rebased, because allowing it

# would result in rebasing already published history.

publish=next

basebranch="$1"

if test "$#" = 2

then

	topic="refs/heads/$2"

else

	topic=`git symbolic-ref HEAD` ||

	exit 0 ;# we do not interrupt rebasing detached HEAD

fi

case "$topic" in

refs/heads/??/*)

	;;

*)

	exit 0 ;# we do not interrupt others.

	;;

esac

# Now we are dealing with a topic branch being rebased

# on top of master.  Is it OK to rebase it?

# Does the topic really exist?

git show-ref -q "$topic" || {

	echo >&2 "No such branch $topic"

	exit 1

}

# Is topic fully merged to master?

not_in_master=`git rev-list --pretty=oneline ^master "$topic"`

if test -z "$not_in_master"

then

	echo >&2 "$topic is fully merged to master; better remove it."

	exit 1 ;# we could allow it, but there is no point.

fi

# Is topic ever merged to next?  If so you should not be rebasing it.

only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`

only_next_2=`git rev-list ^master           ${publish} | sort`

if test "$only_next_1" = "$only_next_2"

then

	not_in_topic=`git rev-list "^$topic" master`

	if test -z "$not_in_topic"

	then

		echo >&2 "$topic is already up-to-date with master"

		exit 1 ;# we could allow it, but there is no point.

	else

		exit 0

	fi

else

	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`

	/usr/bin/perl -e '

		my $topic = $ARGV[0];

		my $msg = "* $topic has commits already merged to public branch:\n";

		my (%not_in_next) = map {

			/^([0-9a-f]+) /;

			($1 => 1);

		} split(/\n/, $ARGV[1]);

		for my $elem (map {

				/^([0-9a-f]+) (.*)$/;

				[$1 => $2];

			} split(/\n/, $ARGV[2])) {

			if (!exists $not_in_next{$elem->[0]}) {

				if ($msg) {

					print STDERR $msg;

					undef $msg;

				}

				print STDERR " $elem->[1]\n";

			}

		}

	' "$topic" "$not_in_next" "$not_in_master"

	exit 1

fi

exit 0

################################################################

This sample hook safeguards topic branches that have been

published from being rewound.

The workflow assumed here is:

 * Once a topic branch forks from "master", "master" is never

   merged into it again (either directly or indirectly).

 * Once a topic branch is fully cooked and merged into "master",

   it is deleted.  If you need to build on top of it to correct

   earlier mistakes, a new topic branch is created by forking at

   the tip of the "master".  This is not strictly necessary, but

   it makes it easier to keep your history simple.

 * Whenever you need to test or publish your changes to topic

   branches, merge them into "next" branch.

The script, being an example, hardcodes the publish branch name

to be "next", but it is trivial to make it configurable via

$GIT_DIR/config mechanism.

With this workflow, you would want to know:

(1) ... if a topic branch has ever been merged to "next".  Young

    topic branches can have stupid mistakes you would rather

    clean up before publishing, and things that have not been

    merged into other branches can be easily rebased without

    affecting other people.  But once it is published, you would

    not want to rewind it.

(2) ... if a topic branch has been fully merged to "master".

    Then you can delete it.  More importantly, you should not

    build on top of it -- other people may already want to

    change things related to the topic as patches against your

    "master", so if you need further changes, it is better to

    fork the topic (perhaps with the same name) afresh from the

    tip of "master".

Let's look at this example:

		   o---o---o---o---o---o---o---o---o---o "next"

		  /       /           /           /

		 /   a---a---b A     /           /

		/   /               /           /

	       /   /   c---c---c---c B         /

	      /   /   /             \         /

	     /   /   /   b---b C     \       /

	    /   /   /   /             \     /

    ---o---o---o---o---o---o---o---o---o---o---o "master"

A, B and C are topic branches.

 * A has one fix since it was merged up to "next".

 * B has finished.  It has been fully merged up to "master" and "next",

   and is ready to be deleted.

 * C has not merged to "next" at all.

We would want to allow C to be rebased, refuse A, and encourage

B to be deleted.

To compute (1):

	git rev-list ^master ^topic next

	git rev-list ^master        next

	if these match, topic has not merged in next at all.

To compute (2):

	git rev-list master..topic

	if this is empty, it is fully merged to "master".

#!/bin/sh

#

# An example hook script to prepare the commit log message.

# Called by "git commit" with the name of the file that has the

# commit message, followed by the description of the commit

# message's source.  The hook's purpose is to edit the commit

# message file.  If the hook fails with a non-zero status,

# the commit is aborted.

#

# To enable this hook, rename this file to "prepare-commit-msg".

# This hook includes three examples.  The first comments out the

# "Conflicts:" part of a merge commit.

#

# The second includes the output of "git diff --name-status -r"

# into the message, just before the "git status" output.  It is

# commented because it doesn't cope with --amend or with squashed

# commits.

#

# The third example adds a Signed-off-by line to the message, that can

# still be edited.  This is rarely a good idea.

case "$2,$3" in

  merge,)

    /usr/bin/perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;;

# ,|template,)

#   /usr/bin/perl -i.bak -pe '

#      print "\n" . `git diff --cached --name-status -r`

#	 if /^#/ && $first++ == 0' "$1" ;;

  *) ;;

esac

# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')

# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

#!/bin/sh

#

# An example hook script to blocks unannotated tags from entering.

# Called by "git receive-pack" with arguments: refname sha1-old sha1-new

#

# To enable this hook, rename this file to "update".

#

# Config

# ------

# hooks.allowunannotated

#   This boolean sets whether unannotated tags will be allowed into the

#   repository.  By default they won't be.

# hooks.allowdeletetag

#   This boolean sets whether deleting tags will be allowed in the

#   repository.  By default they won't be.

# hooks.allowmodifytag

#   This boolean sets whether a tag may be modified after creation. By default

#   it won't be.

# hooks.allowdeletebranch

#   This boolean sets whether deleting branches will be allowed in the

#   repository.  By default they won't be.

# hooks.denycreatebranch

#   This boolean sets whether remotely creating branches will be denied

#   in the repository.  By default this is allowed.

#

# --- Command line

refname="$1"

oldrev="$2"

newrev="$3"

# --- Safety check

if [ -z "$GIT_DIR" ]; then

	echo "Don't run this script from the command line." >&2

	echo " (if you want, you could supply GIT_DIR then run" >&2

	echo "  $0 <ref> <oldrev> <newrev>)" >&2

	exit 1

fi

if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then

	echo "usage: $0 <ref> <oldrev> <newrev>" >&2

	exit 1

fi

# --- Config

allowunannotated=$(git config --bool hooks.allowunannotated)

allowdeletebranch=$(git config --bool hooks.allowdeletebranch)

denycreatebranch=$(git config --bool hooks.denycreatebranch)

allowdeletetag=$(git config --bool hooks.allowdeletetag)

allowmodifytag=$(git config --bool hooks.allowmodifytag)

# check for no description

projectdesc=$(sed -e '1q' "$GIT_DIR/description")

case "$projectdesc" in

"Unnamed repository"* | "")

	echo "*** Project description file hasn't been set" >&2

	exit 1

	;;

esac

# --- Check types

# if $newrev is 0000...0000, it's a commit to delete a ref.

zero="0000000000000000000000000000000000000000"

if [ "$newrev" = "$zero" ]; then

	newrev_type=delete

else

	newrev_type=$(git cat-file -t $newrev)

fi

case "$refname","$newrev_type" in

	refs/tags/*,commit)

		# un-annotated tag

		short_refname=${refname##refs/tags/}

		if [ "$allowunannotated" != "true" ]; then

			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2

			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2

			exit 1

		fi

		;;

	refs/tags/*,delete)

		# delete tag

		if [ "$allowdeletetag" != "true" ]; then

			echo "*** Deleting a tag is not allowed in this repository" >&2

			exit 1

		fi

		;;

	refs/tags/*,tag)

		# annotated tag

		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1

		then

			echo "*** Tag '$refname' already exists." >&2

			echo "*** Modifying a tag is not allowed in this repository." >&2

			exit 1

		fi

		;;

	refs/heads/*,commit)

		# branch

		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then

			echo "*** Creating a branch is not allowed in this repository" >&2

			exit 1

		fi

		;;

	refs/heads/*,delete)

		# delete branch

		if [ "$allowdeletebranch" != "true" ]; then

			echo "*** Deleting a branch is not allowed in this repository" >&2

			exit 1

		fi

		;;

	refs/remotes/*,commit)

		# tracking branch

		;;

	refs/remotes/*,delete)

		# delete tracking branch

		if [ "$allowdeletebranch" != "true" ]; then

			echo "*** Deleting a tracking branch is not allowed in this repository" >&2

			exit 1

		fi

		;;

	*)

		# Anything else (is there anything else?)

		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2

		exit 1

		;;

esac

# --- Finished

exit 0

# git ls-files --others --exclude-from=.git/info/exclude

# Lines that start with '#' are comments.

# For a project mostly in C, the following would be a good set of

# exclude patterns (uncomment them if you want to use them):

# *.[oa]

# *~

0000000000000000000000000000000000000000 49515d0b24f5ee3e8608467b51e0aa62670e16b2 Gershon Dublon <gershon@gershon-2.local> 1397319348 -0400	clone: from https://github.com/andyburke/UnityHTTP.git

0000000000000000000000000000000000000000 49515d0b24f5ee3e8608467b51e0aa62670e16b2 Gershon Dublon <gershon@gershon-2.local> 1397319348 -0400	clone: from https://github.com/andyburke/UnityHTTP.git

0000000000000000000000000000000000000000 49515d0b24f5ee3e8608467b51e0aa62670e16b2 Gershon Dublon <gershon@gershon-2.local> 1397319348 -0400	clone: from https://github.com/andyburke/UnityHTTP.git

# pack-refs with: peeled fully-peeled 

49515d0b24f5ee3e8608467b51e0aa62670e16b2 refs/remotes/origin/master

49515d0b24f5ee3e8608467b51e0aa62670e16b2

ref: refs/remotes/origin/master

using System;

using System.Collections.Generic;

using System.Text.RegularExpressions;

// Based on node-cookiejar (https://github.com/bmeck/node-cookiejar)

namespace HTTP

{

	public class CookieAccessInfo

	{

		public string domain = null;

		public string path = null;

		public bool secure = false;

		public bool scriptAccessible = true;

		public CookieAccessInfo( string domain, string path )

		{

			this.domain = domain;

			this.path = path;

		}

		public CookieAccessInfo( string domain, string path, bool secure )

		{

			this.domain = domain;

			this.path = path;

			this.secure = secure;

		}

		public CookieAccessInfo( string domain, string path, bool secure, bool scriptAccessible )

		{

			this.domain = domain;

			this.path = path;

			this.secure = secure;

			this.scriptAccessible = scriptAccessible;

		}

		public CookieAccessInfo( Cookie cookie )

		{

			this.domain = cookie.domain;

			this.path = cookie.path;

			this.secure = cookie.secure;

			this.scriptAccessible = cookie.scriptAccessible;

		}

	}

	public class Cookie

	{

		public string name = null;

		public string value = null;

		public DateTime expirationDate = DateTime.MaxValue;

		public string path = null;

		public string domain = null;

		public bool secure = false;

		public bool scriptAccessible = true;

		private static string cookiePattern = "\\s*([^=]+)(?:=((?:.|\\n)*))?";

		public Cookie( string cookieString )

		{

			string[] parts = cookieString.Split( ';' );

			foreach ( string part in parts )

			{

				Match match = Regex.Match( part, cookiePattern );

				if ( !match.Success )

				{

					throw new Exception( "Could not parse cookie string: " + cookieString );

				}

				if ( this.name == null )

				{

					this.name = match.Groups[ 1 ].Value;

					this.value = match.Groups[ 2 ].Value;

					continue;

				}

				switch( match.Groups[ 1 ].Value.ToLower() )

				{

				case "httponly":

					this.scriptAccessible = false;

					break;

				case "expires":

					this.expirationDate = DateTime.Parse( match.Groups[ 2 ].Value );

					break;

				case "path":

					this.path = match.Groups[ 2 ].Value;

					break;

				case "domain":

					this.domain = match.Groups[ 2 ].Value;

					break;

				case "secure":

					this.secure = true;

					break;

				default:

					// TODO: warn of unknown cookie setting?

					break;

				}

			}

		}

		public bool Matches( CookieAccessInfo accessInfo )

		{

			if (    this.secure != accessInfo.secure

			     || !this.CollidesWith( accessInfo ) )

			{

				return false;

			}

			return true;

		}

		public bool CollidesWith( CookieAccessInfo accessInfo )

		{

			if ( ( this.path != null && accessInfo.path == null ) || ( this.domain != null && accessInfo.domain == null ) )

			{

				return false;

			}

			if ( this.path != null && accessInfo.path != null && accessInfo.path.IndexOf( this.path ) != 0 )

			{

                return false;

			}

			if ( this.domain == accessInfo.domain )

			{

                return true;

			}

			else if ( this.domain != null && this.domain.Length >= 1 && this.domain[ 0 ] == '.' )

			{

                int wildcard = accessInfo.domain.IndexOf( this.domain.Substring( 1 ) );

				if( wildcard == -1 || wildcard != accessInfo.domain.Length - this.domain.Length + 1 )

				{

                    return false;

				}

			}

			else if ( this.domain != null )

			{

                return false;

			}

            return true;

		}

		public string ToValueString()

		{

			return this.name + "=" + this.value;

		}

		public override string ToString()

		{

			List< string > elements = new List< string >();

			elements.Add( this.name + "=" + this.value );

			if( this.expirationDate != DateTime.MaxValue )

			{

				elements.Add( "expires=" + this.expirationDate.ToString() );

			}

			if( this.domain != null )

			{

				elements.Add( "domain=" + this.domain );

			}

			if( this.path != null )

			{

				elements.Add( "path=" + this.path );

			}

			if( this.secure )

			{

				elements.Add( "secure" );

			}

			if( this.scriptAccessible == false )

			{

				elements.Add( "httponly" );

			}

			return String.Join( "; ", elements.ToArray() );

		}

	}

    public delegate void ContentsChangedDelegate();    

	public class CookieJar

	{

		private static string version = "v2";

        private object cookieJarLock = new object();

		private static CookieJar instance;

		public Dictionary< string, List< Cookie > > cookies;

        public ContentsChangedDelegate ContentsChanged;

		public static CookieJar Instance

		{

			get

			{

				if ( instance == null )

				{

					instance = new CookieJar();

				}

				return instance;

			}

		}

		public CookieJar ()

		{

            this.Clear();

		}

        public void Clear()

        {

            lock( cookieJarLock )

            {

                cookies = new Dictionary< string, List< Cookie > >();

                if ( ContentsChanged != null )

                {

                    ContentsChanged();

                }

            }

        }

		public bool SetCookie( Cookie cookie )

		{

            lock( cookieJarLock )

            {

                bool expired = cookie.expirationDate < DateTime.Now;

                if ( cookies.ContainsKey( cookie.name ) )

                {

                    for( int index = 0; index < cookies[ cookie.name ].Count; ++index )

                    {

                        Cookie collidableCookie = cookies[ cookie.name ][ index ];

                        if ( collidableCookie.CollidesWith( new CookieAccessInfo( cookie ) ) )

                        {

                            if( expired )

                            {

                                cookies[ cookie.name ].RemoveAt( index );

                                if ( cookies[ cookie.name ].Count == 0 )

                                {

                                    cookies.Remove( cookie.name );

                                    if ( ContentsChanged != null )

                                    {

                                        ContentsChanged();

                                    }

                                }

                                return false;

                            }

                            else

                            {

                                cookies[ cookie.name ][ index ] = cookie;

                                if ( ContentsChanged != null )

                                {

                                    ContentsChanged();

                                }

                                return true;

                            }

                        }

                    }

                    if ( expired )

                    {

                        return false;

                    }

                    cookies[ cookie.name ].Add( cookie );

                    if ( ContentsChanged != null )

                    {

                        ContentsChanged();

                    }

                    return true;

                }

                if ( expired )

                {

                    return false;

                }

                cookies[ cookie.name ] = new List< Cookie >();

                cookies[ cookie.name ].Add( cookie );

                if ( ContentsChanged != null )

                {

                    ContentsChanged();

                }

                return true;

            }

		}

        // TODO: figure out a way to respect the scriptAccessible flag and supress cookies being

        //       returned that should not be.  The issue is that at some point, within this

        //       library, we need to send all the correct cookies back in the request.  Right now

        //       there's no way to add all cookies (regardless of script accessibility) to the

        //       request without exposing cookies that should not be script accessible.

		public Cookie GetCookie( string name, CookieAccessInfo accessInfo )

		{

			if ( !cookies.ContainsKey( name ) )

			{

                return null;

			}

			for ( int index = 0; index < cookies[ name ].Count; ++index )

			{

				Cookie cookie = cookies[ name ][ index ];

				if ( cookie.expirationDate > DateTime.Now && cookie.Matches( accessInfo ) )

				{

                    return cookie;

				}

			}

            return null;

		}

		public List< Cookie > GetCookies( CookieAccessInfo accessInfo )

		{

			List< Cookie > result = new List< Cookie >();

			foreach ( string cookieName in cookies.Keys )

			{

                Cookie cookie = this.GetCookie( cookieName, accessInfo );

				if ( cookie != null )

				{

                    result.Add( cookie );

				}

			}

			return result;

		}

		public void SetCookies( Cookie[] cookieObjects )

		{

			for ( var index = 0; index < cookieObjects.Length; ++index )

			{

				this.SetCookie( cookieObjects[ index ] );

			}

		}

		private static string cookiesStringPattern = "[:](?=\\s*[a-zA-Z0-9_\\-]+\\s*[=])";

		public void SetCookies( string cookiesString )

		{

			Match match = Regex.Match( cookiesString, cookiesStringPattern );

			if ( !match.Success )

			{

				throw new Exception( "Could not parse cookies string: " + cookiesString );

			}

			for ( int index = 0; index < match.Groups.Count; ++index )

			{

				this.SetCookie( new Cookie( match.Groups[ index ].Value ) );

			}

		}

        private static string boundary = "\n!!::!!\n";

        public string Serialize()

        {

            string result = version + boundary;

            lock( cookieJarLock )

            {

                foreach ( string key in cookies.Keys )

                {

                    for ( int index = 0; index < cookies[ key ].Count; ++index )

                    {

                        result += cookies[ key ][ index ].ToString() + boundary;

                    }

                }

            }

            return result;

        }

        public void Deserialize( string cookieJarString, bool clear )

        {

            if ( clear )

            {

                this.Clear();

            }

            Regex regex = new Regex( boundary );

            string[] cookieStrings = regex.Split( cookieJarString );

			bool readVersion = false;

            foreach ( string cookieString in cookieStrings )

            {

				if ( !readVersion )

				{

					if ( cookieString.IndexOf( version ) != 0 )

					{

						return;

					}

					readVersion = true;

					continue;

				}

                if ( cookieString.Length > 0 )

                {

                    this.SetCookie( new Cookie( cookieString ) );

                }

            }

        }

	}

}

fileFormatVersion: 2

guid: 442d99c458b3b474f87c874ee99bf01c

MonoImporter:

  serializedVersion: 2

  defaultReferences: []

  executionOrder: 0

  icon: {instanceID: 0}

  userData: 

using UnityEngine;

using System.Collections;

using System.IO;

using System;

using HTTP;

namespace HTTP

{

	public class DiskCacheOperation

	{

		public bool isDone = false;

		public bool fromCache = false;

		public Request request = null;

	}

#if UNITY_WEBPLAYER

	public class DiskCache : MonoBehaviour

	{

		static DiskCache _instance = null;

		public static DiskCache Instance {

			get {

				if (_instance == null) {

					var g = new GameObject ("DiskCache", typeof(DiskCache));

					g.hideFlags = HideFlags.HideAndDontSave;

					_instance = g.GetComponent<DiskCache> ();

				}

				return _instance;

			}

		}

		public DiskCacheOperation Fetch (Request request)

		{

			var handle = new DiskCacheOperation ();

			handle.request = request;

			StartCoroutine (Download (request, handle));

			return handle;

		}

		IEnumerator Download(Request request, DiskCacheOperation handle)

		{

			request.Send ();

			while (!request.isDone)

				yield return new WaitForEndOfFrame ();

			handle.isDone = true;

		}

	}

#else

	public class DiskCache : MonoBehaviour

	{

		string cachePath = null;

		static DiskCache _instance = null;

		public static DiskCache Instance {

			get {

				if (_instance == null) {

					var g = new GameObject ("DiskCache", typeof(DiskCache));

					g.hideFlags = HideFlags.HideAndDontSave;

					_instance = g.GetComponent<DiskCache> ();

				}

				return _instance;

			}

		}

		void Awake ()

		{

			cachePath = System.IO.Path.Combine (Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData), "uwcache");

			if (!Directory.Exists (cachePath))

				Directory.CreateDirectory (cachePath);

		}

		public DiskCacheOperation Fetch (Request request)

		{

			var guid = "";

            // MD5 is disposable

            // http://msdn.microsoft.com/en-us/library/system.security.cryptography.md5.aspx#3

            using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create ()) {

                foreach (var b in md5.ComputeHash (System.Text.ASCIIEncoding.ASCII.GetBytes (request.uri.ToString ()))) {

                    guid = guid + b.ToString ("X2");

                }

            }

			var filename = System.IO.Path.Combine (cachePath, guid);

			if (File.Exists (filename) && File.Exists (filename + ".etag"))

				request.SetHeader ("If-None-Match", File.ReadAllText (filename + ".etag"));

			var handle = new DiskCacheOperation ();

			handle.request = request;

			StartCoroutine (DownloadAndSave (request, filename, handle));

			return handle;

		}

		IEnumerator DownloadAndSave (Request request, string filename, DiskCacheOperation handle)

		{

			var useCachedVersion = File.Exists(filename);

            Action< HTTP.Request > callback = request.completedCallback;

			request.Send(); // will clear the completedCallback

			while (!request.isDone)

				yield return new WaitForEndOfFrame ();

			if (request.exception == null && request.response != null) {

				if (request.response.status == 200) {

					var etag = request.response.GetHeader ("etag");

					if (etag != "") {

						File.WriteAllBytes (filename, request.response.bytes);

						File.WriteAllText (filename + ".etag", etag);

					}

					useCachedVersion = false;

				}

			}

			if(useCachedVersion) {

				if(request.exception != null) {

					Debug.LogWarning("Using cached version due to exception:" + request.exception);

					request.exception = null;

				}

				request.response.status = 304;

				request.response.bytes = File.ReadAllBytes (filename);

				request.isDone = true;

			}

			handle.isDone = true;

            if ( callback != null )

            {

                callback( request );

            }

		}

	}

#endif

}

fileFormatVersion: 2

guid: aed0c7c5135274839ae73978ed82f229

MonoImporter:

  serializedVersion: 2

  defaultReferences: []

  executionOrder: 0

  icon: {instanceID: 0}

  userData: 

<?xml version="1.0" encoding="utf-8"?>

<Project DefaultTargets="Build" ToolsVersion="3.5" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProductVersion>9.0.21022</ProductVersion>

    <SchemaVersion>2.0</SchemaVersion>

    <ProjectGuid>{8E94F9A4-3E1E-42F4-86E8-58270D44A4D8}</ProjectGuid>

    <OutputType>Library</OutputType>

    <RootNamespace>HTTP</RootNamespace>

    <AssemblyName>HTTP</AssemblyName>

    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>

    <ReleaseVersion>0.3</ReleaseVersion>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug</OutputPath>

    <DefineConstants>DEBUG</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <ConsolePause>false</ConsolePause>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>none</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Release</OutputPath>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <ConsolePause>false</ConsolePause>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="System" />

    <Reference Include="Ionic.Zlib, Version=1.9.1.5, Culture=neutral, PublicKeyToken=edbe51ad942a3f5c">

      <SpecificVersion>False</SpecificVersion>

      <HintPath>..\..\..\..\Unity\DMU\Assets\DMU\DLL\Ionic.Zlib.dll</HintPath>

    </Reference>

    <Reference Include="UnityEngine, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null">

      <SpecificVersion>False</SpecificVersion>

      <HintPath>..\..\..\..\..\..\Applications\Unity\Unity.app\Contents\Frameworks\Managed\UnityEngine.dll</HintPath>

    </Reference>

  </ItemGroup>

  <ItemGroup>

    <Compile Include="AssemblyInfo.cs" />

    <Compile Include="Request.cs" />

    <Compile Include="Response.cs" />

    <Compile Include="DiskCache.cs" />

  </ItemGroup>

  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />

</Project>

fileFormatVersion: 2

guid: 2ebd31919153d4fdd83d89c9e8f5c4cd

DefaultImporter:

  userData: 

fileFormatVersion: 2

guid: 52836928634f549edadb7c031f35e13a

DefaultImporter:

  userData: 

# Attribution

Based on Simon Wittber's UnityWeb code (http://code.google.com/p/unityweb/).

# About

This is a TcpClient-based HTTP library for use in Unity.  It should work in

both the standalone player and in the web player.

It also has convenience methods for working with JSON.

# Examples

IEnumerator example:

```C#

public IEnumerator SomeRoutine() {

    HTTP.Request someRequest = new HTTP.Request( "get", "http://someurl.com/somewhere" );

    someRequest.Send();

    while( !someRequest.isDone )

    {

        yield return null;

    }

    // parse some JSON, for example:

    JSONObject thing = new JSONObject( request.response.Text );

}

```

Closure-style (does not need to be in a coroutine):

```C#

HTTP.Request someRequest = new HTTP.Request( "get", "http://someurl.com/somewhere" );

someRequest.Send( ( request ) => {

    // parse some JSON, for example:

    JSONObject thing = new JSONObject( request.response.Text );

});

```

Post request using form data:

```C#

WWWForm form = new WWWForm();

form.AddField( "something", "yo" );

form.AddField( "otherthing", "hey" );

HTTP.Request someRequest = new HTTP.Request( "post", "http://someurl.com/some/post/handler", form );

someRequest.Send( ( request ) => {

    // parse some JSON, for example:

    bool result = false;

    Hashtable thing = (Hashtable)JSON.JsonDecode( request.response.Text, ref result );

    if ( !result )

    {

        Debug.LogWarning( "Could not parse JSON response!" );

        return;

    }

});

```

Post request using JSON:

```C#

Hashtable data = new Hashtable();

data.Add( "something", "hey!" );

data.Add( "otherthing", "YO!!!!" );

// When you pass a Hashtable as the third argument, we assume you want it send as JSON-encoded

// data.  We'll encode it to JSON for you and set the Content-Type header to application/json

HTTP.Request theRequest = new HTTP.Request( "post", "http://someurl.com/a/json/post/handler", data );

theRequest.Send( ( request ) => {

    // we provide Object and Array convenience methods that attempt to parse the response as JSON

    // if the response cannot be parsed, we will return null

    // note that if you want to send json that isn't either an object ({...}) or an array ([...])

    // that you should use JSON.JsonDecode directly on the response.Text, Object and Array are

    // only provided for convenience

    Hashtable result = request.response.Object;

    if ( result == null )

    {

        Debug.LogWarning( "Could not parse JSON response!" );

        return;

    }

});

```

If you want to make a request while not in Play Mode (e. g. from a custom Editor menu command or wizard), you must use the Request synchronously, since Unity's main update loop is not running. The call will block until the response is available.

```C#

Hashtable data = new Hashtable();

data.Add( "something", "hey!" );

data.Add( "otherthing", "YO!!!!" );

HTTP.Request theRequest = new HTTP.Request("post", "http://someurl.com/a/json/post/handler", data );

theRequest.synchronous = true;

theRequest.Send((request) => {

	EditorUtility.DisplayDialog("Request was posted.", request.response.Text, "Ok");

});

```

fileFormatVersion: 2

guid: 28e0d55dee56640259e2333887caf8fd

DefaultImporter:

  userData: 

using UnityEngine;

using System;

using System.IO;

using System.Text;

using System.Collections;

using System.Collections.Generic;

using System.Net.Sockets;

using System.Globalization;

using System.Threading;

using System.Net.Security;

using System.Security.Authentication;

using System.Security.Cryptography.X509Certificates;

namespace HTTP

{

	public class HTTPException : Exception

	{

		public HTTPException (string message) : base(message)

		{

		}

	}

	public enum RequestState {

		Waiting, Reading, Done

	}

	public class Request

	{

        public static bool LogAllRequests = false;

        public static bool VerboseLogging = false;

		public CookieJar cookieJar = CookieJar.Instance;

		public string method = "GET";

		public string protocol = "HTTP/1.1";

		public byte[] bytes;

		public Uri uri;

		public static byte[] EOL = { (byte)'\r', (byte)'\n' };

		public Response response = null;

		public bool isDone = false;

		public int maximumRetryCount = 8;

		public bool acceptGzip = true;

		public bool useCache = false;

		public Exception exception = null;

		public RequestState state = RequestState.Waiting;

        public long responseTime = 0; // in milliseconds

		public bool synchronous = false;

		public Action< HTTP.Request > completedCallback = null;

		Dictionary<string, List<string>> headers = new Dictionary<string, List<string>> ();

		static Dictionary<string, string> etags = new Dictionary<string, string> ();

		public Request (string method, string uri)

		{

			this.method = method;

			this.uri = new Uri (uri);

		}

		public Request (string method, string uri, bool useCache)

		{

			this.method = method;

			this.uri = new Uri (uri);

			this.useCache = useCache;

		}

		public Request (string method, string uri, byte[] bytes)

		{

			this.method = method;

			this.uri = new Uri (uri);

			this.bytes = bytes;

		}

        public Request( string method, string uri, WWWForm form )

        {

			this.method = method;

			this.uri = new Uri (uri);

			this.bytes = form.data;

            foreach ( DictionaryEntry entry in form.headers )

            {

                this.AddHeader( (string)entry.Key, (string)entry.Value );

            }

        }

        public Request( string method, string uri, Hashtable data )

        {

            this.method = method;

            this.uri = new Uri( uri );

            this.bytes = Encoding.UTF8.GetBytes( JSON.JsonEncode( data ) );

            this.AddHeader( "Content-Type", "application/json" );

        }

		public void AddHeader (string name, string value)

		{

			name = name.ToLower ().Trim ();

			value = value.Trim ();

			if (!headers.ContainsKey (name))

				headers[name] = new List<string> ();

			headers[name].Add (value);

		}

		public string GetHeader (string name)

		{

			name = name.ToLower ().Trim ();

			if (!headers.ContainsKey (name))

				return "";

			return headers[name][0];

		}

        public List< string > GetHeaders()

        {

            List< string > result = new List< string >();

            foreach (string name in headers.Keys) {

				foreach (string value in headers[name]) {

                    result.Add( name + ": " + value );

				}

			}

            return result;

        }

		public List<string> GetHeaders (string name)

		{

			name = name.ToLower ().Trim ();

			if (!headers.ContainsKey (name))