Update to MediaWiki 1.18.0

* also update ArchLinux skin to chagnes in MonoBook
* Use only css to hide our menu bar when printing

5 files changed, 817 insertions, 306 deletions

diff --git a/includes/upload/UploadBase.php b/includes/upload/UploadBase.php
index 546b9db8..a97edbc7 100644
--- a/includes/upload/UploadBase.php
+++ b/includes/upload/UploadBase.php
@@ -18,14 +18,16 @@ abstract class UploadBase {
 	protected $mDesiredDestName, $mDestName, $mRemoveTempFile, $mSourceType;
 	protected $mTitle = false, $mTitleError = 0;
 	protected $mFilteredName, $mFinalExtension;
-	protected $mLocalFile;
+	protected $mLocalFile, $mFileSize, $mFileProps;
+	protected $mBlackListedExtensions;
+	protected $mJavaDetected;
 
 	const SUCCESS = 0;
 	const OK = 0;
 	const EMPTY_FILE = 3;
 	const MIN_LENGTH_PARTNAME = 4;
 	const ILLEGAL_FILENAME = 5;
-	const OVERWRITE_EXISTING_FILE = 7; # Not used anymore; handled by verifyPermissions()
+	const OVERWRITE_EXISTING_FILE = 7; # Not used anymore; handled by verifyTitlePermissions()
 	const FILETYPE_MISSING = 8;
 	const FILETYPE_BADTYPE = 9;
 	const VERIFICATION_ERROR = 10;
@@ -34,13 +36,7 @@ abstract class UploadBase {
 	const UPLOAD_VERIFICATION_ERROR = 11;
 	const HOOK_ABORTED = 11;
 	const FILE_TOO_LARGE = 12;
-
-	const SESSION_VERSION = 2;
-	const SESSION_KEYNAME = 'wsUploadData';
-
-	static public function getSessionKeyname() {
-		return self::SESSION_KEYNAME;
-	}
+	const WINDOWS_NONASCII_FILENAME = 13;
 
 	public function getVerificationErrorCode( $error ) {
 		$code_to_status = array(self::EMPTY_FILE => 'empty-file',
@@ -52,6 +48,7 @@ abstract class UploadBase {
 								self::OVERWRITE_EXISTING_FILE => 'overwrite',
 								self::VERIFICATION_ERROR => 'verification-error',
 								self::HOOK_ABORTED =>  'hookaborted',
+								self::WINDOWS_NONASCII_FILENAME => 'windows-nonascii-filename',
 		);
 		if( isset( $code_to_status[$error] ) ) {
 			return $code_to_status[$error];
@@ -66,21 +63,21 @@ abstract class UploadBase {
 	 */
 	public static function isEnabled() {
 		global $wgEnableUploads;
+
 		if ( !$wgEnableUploads ) {
 			return false;
 		}
 
 		# Check php's file_uploads setting
-		if( !wfIniGetBool( 'file_uploads' ) ) {
-			return false;
-		}
-		return true;
+		return wfIsHipHop() || wfIniGetBool( 'file_uploads' );
 	}
 
 	/**
 	 * Returns true if the user can use this upload module or else a string
 	 * identifying the missing permission.
 	 * Can be overriden by subclasses.
+	 *
+	 * @param $user User
 	 */
 	public static function isAllowed( $user ) {
 		foreach ( array( 'upload', 'edit' ) as $permission ) {
@@ -96,6 +93,9 @@ abstract class UploadBase {
 
 	/**
 	 * Create a form of UploadBase depending on wpSourceType and initializes it
+	 *
+	 * @param $request WebRequest
+	 * @param $type
 	 */
 	public static function createFromRequest( &$request, $type = null ) {
 		$type = $type ? $type : $request->getVal( 'wpSourceType', 'File' );
@@ -144,6 +144,14 @@ abstract class UploadBase {
 	public function __construct() {}
 
 	/**
+	 * Returns the upload type. Should be overridden by child classes
+	 *
+	 * @since 1.18
+	 * @return string
+	 */
+	public function getSourceType() { return null; }
+
+	/**
 	 * Initialize the path information
 	 * @param $name string the desired destination name
 	 * @param $tempPath string the temporary path
@@ -200,6 +208,19 @@ abstract class UploadBase {
 	}
 
 	/**
+	 * Finish appending to the Repo file
+	 *
+	 * @param $toAppendPath String: path to the Repo file that will be appended to.
+	 * @return Status Status
+	 */
+	protected function appendFinish( $toAppendPath ) {
+		$repo = RepoGroup::singleton()->getLocalRepo();
+		$status = $repo->appendFinish( $toAppendPath );
+		return $status;
+	}
+
+
+	/**
 	 * @param $srcPath String: the source path
 	 * @return the real path if it was a virtual URL
 	 */
@@ -226,11 +247,11 @@ abstract class UploadBase {
 		/**
 		 * Honor $wgMaxUploadSize
 		 */
-		global $wgMaxUploadSize;
-		if( $this->mFileSize > $wgMaxUploadSize ) {
-			return array( 
+		$maxSize = self::getMaxUploadSize( $this->getSourceType() );
+		if( $this->mFileSize > $maxSize ) {
+			return array(
 				'status' => self::FILE_TOO_LARGE,
-				'max' => $wgMaxUploadSize,
+				'max' => $maxSize,
 			);
 		}
 
@@ -279,6 +300,9 @@ abstract class UploadBase {
 			}
 			if ( $this->mTitleError == self::FILETYPE_BADTYPE ) {
 				$result['finalExt'] = $this->mFinalExtension;
+				if ( count( $this->mBlackListedExtensions ) ) {
+					$result['blacklistedExt'] = $this->mBlackListedExtensions;
+				}
 			}
 			return $result;
 		}
@@ -297,15 +321,16 @@ abstract class UploadBase {
 		global $wgVerifyMimeType;
 		if ( $wgVerifyMimeType ) {
 			wfDebug ( "\n\nmime: <$mime> extension: <{$this->mFinalExtension}>\n\n");
-			if ( !$this->verifyExtension( $mime, $this->mFinalExtension ) ) {
-				return array( 'filetype-mime-mismatch' );
-			}
-
 			global $wgMimeTypeBlacklist;
 			if ( $this->checkFileExtension( $mime, $wgMimeTypeBlacklist ) ) {
 				return array( 'filetype-badmime', $mime );
 			}
 
+			# XXX: Missing extension will be caught by validateName() via getTitle()
+			if ( $this->mFinalExtension != '' && !$this->verifyExtension( $mime, $this->mFinalExtension ) ) {
+				return array( 'filetype-mime-mismatch', $this->mFinalExtension, $mime );
+			}
+
 			# Check IE type
 			$fp = fopen( $this->mTempPath, 'rb' );
 			$chunk = fread( $fp, 256 );
@@ -330,12 +355,12 @@ abstract class UploadBase {
 	 * @return mixed true of the file is verified, array otherwise.
 	 */
 	protected function verifyFile() {
+		global $wgAllowJavaUploads;
 		# get the title, even though we are doing nothing with it, because
-		# we need to populate mFinalExtension 
+		# we need to populate mFinalExtension
 		$this->getTitle();
-		
+
 		$this->mFileProps = File::getPropsFromPath( $this->mTempPath, $this->mFinalExtension );
-		$this->checkMacBinary();
 
 		# check mime type, if desired
 		$mime = $this->mFileProps[ 'file-mime' ];
@@ -354,9 +379,25 @@ abstract class UploadBase {
 			}
 		}
 
-		/**
-		* Scan the uploaded file for viruses
-		*/
+		# Check for Java applets, which if uploaded can bypass cross-site
+		# restrictions.
+		if ( !$wgAllowJavaUploads ) {
+			$this->mJavaDetected = false;
+			$zipStatus = ZipDirectoryReader::read( $this->mTempPath,
+				array( $this, 'zipEntryCallback' ) );
+			if ( !$zipStatus->isOK() ) {
+				$errors = $zipStatus->getErrorsArray();
+				$error = reset( $errors );
+				if ( $error[0] !== 'zip-wrong-format' ) {
+					return $error;
+				}
+			}
+			if ( $this->mJavaDetected ) {
+				return array( 'uploadjava' );
+			}
+		}
+
+		# Scan the uploaded file for viruses
 		$virus = $this->detectVirus( $this->mTempPath );
 		if ( $virus ) {
 			return array( 'uploadvirus', $virus );
@@ -381,17 +422,51 @@ abstract class UploadBase {
 	}
 
 	/**
+	 * Callback for ZipDirectoryReader to detect Java class files.
+	 */
+	function zipEntryCallback( $entry ) {
+		$names = array( $entry['name'] );
+
+		// If there is a null character, cut off the name at it, because JDK's
+		// ZIP_GetEntry() uses strcmp() if the name hashes match. If a file name
+		// were constructed which had ".class\0" followed by a string chosen to
+		// make the hash collide with the truncated name, that file could be
+		// returned in response to a request for the .class file.
+		$nullPos = strpos( $entry['name'], "\000" );
+		if ( $nullPos !== false ) {
+			$names[] = substr( $entry['name'], 0, $nullPos );
+		}
+
+		// If there is a trailing slash in the file name, we have to strip it,
+		// because that's what ZIP_GetEntry() does.
+		if ( preg_grep( '!\.class/?$!', $names ) ) {
+			$this->mJavaDetected = true;
+		}
+	}
+
+	/**
+	 * Alias for verifyTitlePermissions. The function was originally 'verifyPermissions' 
+	 * but that suggests it's checking the user, when it's really checking the title + user combination.
+	 * @param $user User object to verify the permissions against
+	 * @return mixed An array as returned by getUserPermissionsErrors or true
+	 *               in case the user has proper permissions.
+	 */
+	public function verifyPermissions( $user ) {
+		return $this->verifyTitlePermissions( $user );
+	}
+
+	/**
 	 * Check whether the user can edit, upload and create the image. This
 	 * checks only against the current title; if it returns errors, it may
 	 * very well be that another title will not give errors. Therefore
 	 * isAllowed() should be called as well for generic is-user-blocked or
 	 * can-user-upload checking.
 	 *
-	 * @param $user the User object to verify the permissions against
+	 * @param $user User object to verify the permissions against
 	 * @return mixed An array as returned by getUserPermissionsErrors or true
 	 *               in case the user has proper permissions.
 	 */
-	public function verifyPermissions( $user ) {
+	public function verifyTitlePermissions( $user ) {
 		/**
 		 * If the image is protected, non-sysop users won't be able
 		 * to modify it by uploading a new revision.
@@ -412,12 +487,12 @@ abstract class UploadBase {
 			$permErrors = array_merge( $permErrors, wfArrayDiff2( $permErrorsCreate, $permErrors ) );
 			return $permErrors;
 		}
-		
+
 		$overwriteError = $this->checkOverwrite( $user );
 		if ( $overwriteError !== true ) {
 			return array( $overwriteError );
 		}
-		
+
 		return true;
 	}
 
@@ -427,11 +502,12 @@ abstract class UploadBase {
 	 * @return Array of warnings
 	 */
 	public function checkWarnings() {
+		global $wgLang;
+
 		$warnings = array();
 
 		$localFile = $this->getLocalFile();
 		$filename = $localFile->getName();
-		$n = strrpos( $filename, '.' );
 
 		/**
 		 * Check whether the resulting filename is different from the desired one,
@@ -448,7 +524,8 @@ abstract class UploadBase {
 		global $wgCheckFileExtensions, $wgFileExtensions;
 		if ( $wgCheckFileExtensions ) {
 			if ( !$this->checkFileExtension( $this->mFinalExtension, $wgFileExtensions ) ) {
-				$warnings['filetype-unwanted-type'] = $this->mFinalExtension;
+				$warnings['filetype-unwanted-type'] = array( $this->mFinalExtension,
+					$wgLang->commaList( $wgFileExtensions ), count( $wgFileExtensions ) );
 			}
 		}
 
@@ -493,24 +570,26 @@ abstract class UploadBase {
 	 * Really perform the upload. Stores the file in the local repo, watches
 	 * if necessary and runs the UploadComplete hook.
 	 *
-	 * @return mixed Status indicating the whether the upload succeeded.
+	 * @param $user User
+	 *
+	 * @return Status indicating the whether the upload succeeded.
 	 */
 	public function performUpload( $comment, $pageText, $watch, $user ) {
-		$status = $this->getLocalFile()->upload( 
-			$this->mTempPath, 
-			$comment, 
+		$status = $this->getLocalFile()->upload(
+			$this->mTempPath,
+			$comment,
 			$pageText,
 			File::DELETE_SOURCE,
-			$this->mFileProps, 
-			false, 
-			$user 
+			$this->mFileProps,
+			false,
+			$user
 		);
 
 		if( $status->isGood() ) {
 			if ( $watch ) {
 				$user->addWatch( $this->getLocalFile()->getTitle() );
 			}
-
+						
 			wfRunHooks( 'UploadComplete', array( &$this ) );
 		}
 
@@ -527,13 +606,23 @@ abstract class UploadBase {
 		if ( $this->mTitle !== false ) {
 			return $this->mTitle;
 		}
+		
+		/* Assume that if a user specified File:Something.jpg, this is an error
+		 * and that the namespace prefix needs to be stripped of.
+		 */
+		$title = Title::newFromText( $this->mDesiredDestName );
+		if ( $title && $title->getNamespace() == NS_FILE ) {
+			$this->mFilteredName = $title->getDBkey();
+		} else {
+			$this->mFilteredName = $this->mDesiredDestName;
+		}
 
 		/**
 		 * Chop off any directories in the given filename. Then
 		 * filter out illegal characters, and try to make a legible name
 		 * out of it. We'll strip some silently that Title would die on.
 		 */
-		$this->mFilteredName = wfStripIllegalFilenameChars( $this->mDesiredDestName );
+		$this->mFilteredName = wfStripIllegalFilenameChars( $this->mFilteredName );
 		/* Normalize to title form before we do any further processing */
 		$nt = Title::makeTitleSafe( NS_FILE, $this->mFilteredName );
 		if( is_null( $nt ) ) {
@@ -552,20 +641,48 @@ abstract class UploadBase {
 			$this->mFinalExtension = trim( $ext[count( $ext ) - 1] );
 		} else {
 			$this->mFinalExtension = '';
+
+			# No extension, try guessing one
+			$magic = MimeMagic::singleton();
+			$mime = $magic->guessMimeType( $this->mTempPath );
+			if ( $mime !== 'unknown/unknown' ) {
+				# Get a space separated list of extensions
+				$extList = $magic->getExtensionsForType( $mime );
+				if ( $extList ) {
+					# Set the extension to the canonical extension
+					$this->mFinalExtension = strtok( $extList, ' ' );
+
+					# Fix up the other variables
+					$this->mFilteredName .= ".{$this->mFinalExtension}";
+					$nt = Title::makeTitleSafe( NS_FILE, $this->mFilteredName );
+					$ext = array( $this->mFinalExtension );
+				}
+			}
+
 		}
 
 		/* Don't allow users to override the blacklist (check file extension) */
 		global $wgCheckFileExtensions, $wgStrictFileExtensions;
 		global $wgFileExtensions, $wgFileBlacklist;
+
+		$blackListedExtensions = $this->checkFileExtensionList( $ext, $wgFileBlacklist );
+
 		if ( $this->mFinalExtension == '' ) {
 			$this->mTitleError = self::FILETYPE_MISSING;
 			return $this->mTitle = null;
-		} elseif ( $this->checkFileExtensionList( $ext, $wgFileBlacklist ) ||
+		} elseif ( $blackListedExtensions ||
 				( $wgCheckFileExtensions && $wgStrictFileExtensions &&
-					!$this->checkFileExtension( $this->mFinalExtension, $wgFileExtensions ) ) ) {
+					!$this->checkFileExtensionList( $ext, $wgFileExtensions ) ) ) {
+			$this->mBlackListedExtensions = $blackListedExtensions;
 			$this->mTitleError = self::FILETYPE_BADTYPE;
 			return $this->mTitle = null;
 		}
+		
+		// Windows may be broken with special characters, see bug XXX
+		if ( wfIsWindows() && !preg_match( '/^[\x0-\x7f]*$/', $nt->getText() ) ) {
+			$this->mTitleError = self::WINDOWS_NONASCII_FILENAME;
+			return $this->mTitle = null;
+		}
 
 		# If there was more than one "extension", reassemble the base
 		# filename to prevent bogus complaints about length
@@ -585,6 +702,8 @@ abstract class UploadBase {
 
 	/**
 	 * Return the local file and initializes if necessary.
+	 *
+	 * @return LocalFile
 	 */
 	public function getLocalFile() {
 		if( is_null( $this->mLocalFile ) ) {
@@ -619,31 +738,40 @@ abstract class UploadBase {
 	 * by design) then we may want to stash the file temporarily, get more information, and publish the file later.
 	 *
 	 * This method will stash a file in a temporary directory for later processing, and save the necessary descriptive info
-	 * into the user's session.
-	 * This method returns the file object, which also has a 'sessionKey' property which can be passed through a form or 
+	 * into the database.
+	 * This method returns the file object, which also has a 'fileKey' property which can be passed through a form or
 	 * API request to find this stashed file again.
 	 *
-	 * @param $key String: (optional) the session key used to find the file info again. If not supplied, a key will be autogenerated.
-	 * @return File: stashed file
+	 * @param $key String: (optional) the file key used to find the file info again. If not supplied, a key will be autogenerated.
+	 * @return UploadStashFile stashed file
 	 */
-	public function stashSessionFile( $key = null ) { 
+	public function stashFile( $key = null ) {
+		// was stashSessionFile
 		$stash = RepoGroup::singleton()->getLocalRepo()->getUploadStash();
-		$data = array( 
-			'mFileProps' => $this->mFileProps
-		);
-		$file = $stash->stashFile( $this->mTempPath, $data, $key );
+
+		$file = $stash->stashFile( $this->mTempPath, $this->getSourceType(), $key );
 		$this->mLocalFile = $file;
 		return $file;
 	}
 
 	/**
-	 * Stash a file in a temporary directory, returning a key which can be used to find the file again. See stashSessionFile().
+	 * Stash a file in a temporary directory, returning a key which can be used to find the file again. See stashFile().
 	 *
-	 * @param $key String: (optional) the session key used to find the file info again. If not supplied, a key will be autogenerated.
-	 * @return String: session key
+	 * @param $key String: (optional) the file key used to find the file info again. If not supplied, a key will be autogenerated.
+	 * @return String: file key
+	 */
+	public function stashFileGetKey( $key = null ) {
+		return $this->stashFile( $key )->getFileKey();
+	}
+
+	/** 
+	 * alias for stashFileGetKey, for backwards compatibility
+	 *
+	 * @param $key String: (optional) the file key used to find the file info again. If not supplied, a key will be autogenerated.
+	 * @return String: file key
 	 */
 	public function stashSession( $key = null ) {
-		return $this->stashSessionFile( $key )->getSessionKey();
+		return $this->stashFileGetKey( $key );
 	}
 
 	/**
@@ -689,19 +817,14 @@ abstract class UploadBase {
 
 	/**
 	 * Perform case-insensitive match against a list of file extensions.
-	 * Returns true if any of the extensions are in the list.
+	 * Returns an array of matching extensions.
 	 *
 	 * @param $ext Array
 	 * @param $list Array
 	 * @return Boolean
 	 */
 	public static function checkFileExtensionList( $ext, $list ) {
-		foreach( $ext as $e ) {
-			if( in_array( strtolower( $e ), $list ) ) {
-				return true;
-			}
-		}
-		return false;
+		return array_intersect( array_map( 'strtolower', $ext ), $list );
 	}
 
 	/**
@@ -788,7 +911,7 @@ abstract class UploadBase {
 
 		$chunk = trim( $chunk );
 
-		# FIXME: convert from UTF-16 if necessarry!
+		# @todo FIXME: Convert from UTF-16 if necessarry!
 		wfDebug( __METHOD__ . ": checking for embedded scripts and HTML stuff\n" );
 
 		# check for HTML doctype
@@ -828,6 +951,7 @@ abstract class UploadBase {
 
 		foreach( $tags as $tag ) {
 			if( false !== strpos( $chunk, $tag ) ) {
+				wfDebug( __METHOD__ . ": found something that may make it be mistaken for html: $tag\n" );
 				return true;
 			}
 		}
@@ -841,16 +965,19 @@ abstract class UploadBase {
 
 		# look for script-types
 		if( preg_match( '!type\s*=\s*[\'"]?\s*(?:\w*/)?(?:ecma|java)!sim', $chunk ) ) {
+			wfDebug( __METHOD__ . ": found script types\n" );
 			return true;
 		}
 
 		# look for html-style script-urls
 		if( preg_match( '!(?:href|src|data)\s*=\s*[\'"]?\s*(?:ecma|java)script:!sim', $chunk ) ) {
+			wfDebug( __METHOD__ . ": found html-style script urls\n" );
 			return true;
 		}
 
 		# look for css-style script-urls
 		if( preg_match( '!url\s*\(\s*[\'"]?\s*(?:ecma|java)script:!sim', $chunk ) ) {
+			wfDebug( __METHOD__ . ": found css-style script urls\n" );
 			return true;
 		}
 
@@ -989,33 +1116,11 @@ abstract class UploadBase {
 	}
 
 	/**
-	 * Check if the temporary file is MacBinary-encoded, as some uploads
-	 * from Internet Explorer on Mac OS Classic and Mac OS X will be.
-	 * If so, the data fork will be extracted to a second temporary file,
-	 * which will then be checked for validity and either kept or discarded.
-	 */
-	private function checkMacBinary() {
-		$macbin = new MacBinary( $this->mTempPath );
-		if( $macbin->isValid() ) {
-			$dataFile = tempnam( wfTempDir(), 'WikiMacBinary' );
-			$dataHandle = fopen( $dataFile, 'wb' );
-
-			wfDebug( __METHOD__ . ": Extracting MacBinary data fork to $dataFile\n" );
-			$macbin->extractData( $dataHandle );
-
-			$this->mTempPath = $dataFile;
-			$this->mFileSize = $macbin->dataForkLength();
-
-			// We'll have to manually remove the new file if it's not kept.
-			$this->mRemoveTempFile = true;
-		}
-		$macbin->close();
-	}
-
-	/**
 	 * Check if there's an overwrite conflict and, if so, if restrictions
 	 * forbid this user from performing the upload.
 	 *
+	 * @param $user User
+	 *
 	 * @return mixed true on success, array on failure
 	 */
 	private function checkOverwrite( $user ) {
@@ -1072,7 +1177,7 @@ abstract class UploadBase {
 	 * - File exists with normalized extension
 	 * - The file looks like a thumbnail and the original exists
 	 *
-	 * @param $file The File object to check
+	 * @param $file File The File object to check
 	 * @return mixed False if the file does not exists, else an array
 	 */
 	public static function getExistsWarning( $file ) {
@@ -1170,9 +1275,9 @@ abstract class UploadBase {
 	 */
 	public static function getFilenamePrefixBlacklist() {
 		$blacklist = array();
-		$message = wfMsgForContent( 'filename-prefix-blacklist' );
-		if( $message && !( wfEmptyMsg( 'filename-prefix-blacklist', $message ) || $message == '-' ) ) {
-			$lines = explode( "\n", $message );
+		$message = wfMessage( 'filename-prefix-blacklist' )->inContentLanguage();
+		if( !$message->isDisabled() ) {
+			$lines = explode( "\n", $message->plain() );
 			foreach( $lines as $line ) {
 				// Remove comment lines
 				$comment = substr( trim( $line ), 0, 1 );
@@ -1191,18 +1296,18 @@ abstract class UploadBase {
 	}
 
 	/**
-	 * Gets image info about the file just uploaded. 
+	 * Gets image info about the file just uploaded.
 	 *
-	 * Also has the effect of setting metadata to be an 'indexed tag name' in returned API result if 
+	 * Also has the effect of setting metadata to be an 'indexed tag name' in returned API result if
 	 * 'metadata' was requested. Oddly, we have to pass the "result" object down just so it can do that
-	 * with the appropriate format, presumably. 
+	 * with the appropriate format, presumably.
 	 *
 	 * @param $result ApiResult:
 	 * @return Array: image info
 	 */
 	public function getImageInfo( $result ) {
 		$file = $this->getLocalFile();
-		// TODO This cries out for refactoring. We really want to say $file->getAllInfo(); here. 
+		// TODO This cries out for refactoring. We really want to say $file->getAllInfo(); here.
 		// Perhaps "info" methods should be moved into files, and the API should just wrap them in queries.
 		if ( $file instanceof UploadStashFile ) {
 			$imParam = ApiQueryStashImageInfo::getPropertyNames();
@@ -1220,4 +1325,19 @@ abstract class UploadBase {
 		unset( $code['status'] );
 		return Status::newFatal( $this->getVerificationErrorCode( $code ), $error );
 	}
+
+	public static function getMaxUploadSize( $forType = null ) {
+		global $wgMaxUploadSize;
+
+		if ( is_array( $wgMaxUploadSize ) ) {
+			if ( !is_null( $forType ) && isset( $wgMaxUploadSize[$forType] ) ) {
+				return $wgMaxUploadSize[$forType];
+			} else {
+				return $wgMaxUploadSize['*'];
+			}
+		} else {
+			return intval( $wgMaxUploadSize );
+		}
+
+	}
 }
diff --git a/includes/upload/UploadFromFile.php b/includes/upload/UploadFromFile.php
index e67ec191..c2ab6467 100644
--- a/includes/upload/UploadFromFile.php
+++ b/includes/upload/UploadFromFile.php
@@ -8,8 +8,15 @@
  */
 
 class UploadFromFile extends UploadBase {
+
+	/**
+	 * @var WebRequestUpload
+	 */
 	protected $mUpload = null;
 
+	/**
+	 * @param $request WebRequest
+	 */
 	function initializeFromRequest( &$request ) {
 		$upload = $request->getUpload( 'wpUploadFile' );		
 		$desiredDestName = $request->getText( 'wpDestFile' );
@@ -18,31 +25,47 @@ class UploadFromFile extends UploadBase {
 			
 		return $this->initialize( $desiredDestName, $upload );
 	}
-	
+
 	/**
 	 * Initialize from a filename and a WebRequestUpload
+	 * @param $name
+	 * @param $webRequestUpload
 	 */
 	function initialize( $name, $webRequestUpload ) {
 		$this->mUpload = $webRequestUpload;
 		return $this->initializePathInfo( $name, 
 			$this->mUpload->getTempName(), $this->mUpload->getSize() );
 	}
+
+	/**
+	 * @param $request
+	 * @return bool
+	 */
 	static function isValidRequest( $request ) {
 		# Allow all requests, even if no file is present, so that an error
 		# because a post_max_size or upload_max_filesize overflow
 		return true;
 	}
-	
+
+	/**
+	 * @return string
+	 */
+	public function getSourceType() {
+		return 'file';
+	}
+
+	/**
+	 * @return array
+	 */
 	public function verifyUpload() {
 		# Check for a post_max_size or upload_max_size overflow, so that a 
 		# proper error can be shown to the user
 		if ( is_null( $this->mTempPath ) || $this->isEmptyFile() ) {
 			if ( $this->mUpload->isIniSizeOverflow() ) {
-				global $wgMaxUploadSize;
 				return array( 
 					'status' => UploadBase::FILE_TOO_LARGE,
 					'max' => min( 
-						$wgMaxUploadSize, 
+						self::getMaxUploadSize( $this->getSourceType() ), 
 						wfShorthandToInteger( ini_get( 'upload_max_filesize' ) ), 
 						wfShorthandToInteger( ini_get( 'post_max_size' ) )
 					),
@@ -60,6 +83,4 @@ class UploadFromFile extends UploadBase {
 	public function getFileTempname() {
 		return $this->mUpload->getTempname();
 	}
-
-	
 }
diff --git a/includes/upload/UploadFromStash.php b/includes/upload/UploadFromStash.php
index 156781e9..feb14a87 100644
--- a/includes/upload/UploadFromStash.php
+++ b/includes/upload/UploadFromStash.php
@@ -8,66 +8,109 @@
  */
 
 class UploadFromStash extends UploadBase {
-	public static function isValidSessionKey( $key, $sessionData ) {
-		return !empty( $key ) &&
-			is_array( $sessionData ) &&
-			isset( $sessionData[$key] ) &&
-			isset( $sessionData[$key]['version'] ) &&
-			$sessionData[$key]['version'] == UploadBase::SESSION_VERSION;
+	protected $mFileKey, $mVirtualTempPath, $mFileProps, $mSourceType;
+	
+	// an instance of UploadStash
+	private $stash;
+	
+	//LocalFile repo
+	private $repo;
+	
+	public function __construct( $user = false, $stash = false, $repo = false ) {
+		// user object. sometimes this won't exist, as when running from cron.
+		$this->user = $user;
+
+		if( $repo ) {
+			$this->repo = $repo;
+		} else {
+			$this->repo = RepoGroup::singleton()->getLocalRepo();
+		}
+
+		if( $stash ) {
+			$this->stash = $stash;
+		} else {
+			wfDebug( __METHOD__ . " creating new UploadStash instance for " . $user->getId() . "\n" );
+			$this->stash = new UploadStash( $this->repo, $this->user );
+		}
+
+		return true;
+	}
+	
+	public static function isValidKey( $key ) {
+		// this is checked in more detail in UploadStash
+		return preg_match( UploadStash::KEY_FORMAT_REGEX, $key );
 	}
 
+	/**
+	 * @param $request WebRequest
+	 *
+	 * @return Boolean
+	 */
 	public static function isValidRequest( $request ) {
-		$sessionData = $request->getSessionData( UploadBase::SESSION_KEYNAME );
-		return self::isValidSessionKey(
-			$request->getText( 'wpSessionKey' ),
-			$sessionData
-		);
+		return self::isValidKey( $request->getText( 'wpFileKey' ) || $request->getText( 'wpSessionKey' ) );
 	}
 
-	public function initialize( $name, $sessionKey, $sessionData ) {
-			/**
-			 * Confirming a temporarily stashed upload.
-			 * We don't want path names to be forged, so we keep
-			 * them in the session on the server and just give
-			 * an opaque key to the user agent.
-			 */
-
-			$this->initializePathInfo( $name,
-				$this->getRealPath ( $sessionData['mTempPath'] ),
-				$sessionData['mFileSize'],
-				false
-			);
-			
-			$this->mSessionKey = $sessionKey;
-			$this->mVirtualTempPath = $sessionData['mTempPath'];
-			$this->mFileProps = $sessionData['mFileProps'];
+	public function initialize( $key, $name = 'upload_file' ) {
+		/**
+		 * Confirming a temporarily stashed upload.
+		 * We don't want path names to be forged, so we keep
+		 * them in the session on the server and just give
+		 * an opaque key to the user agent.
+		 */		
+		$metadata = $this->stash->getMetadata( $key );
+		$this->initializePathInfo( $name,
+			$this->getRealPath ( $metadata['us_path'] ),
+			$metadata['us_size'],
+			false
+		);
+
+		$this->mFileKey = $key;
+		$this->mVirtualTempPath = $metadata['us_path'];
+		$this->mFileProps = $this->stash->getFileProps( $key );
+		$this->mSourceType = $metadata['us_source_type'];
 	}
 
+	/**
+	 * @param $request WebRequest
+	 */
 	public function initializeFromRequest( &$request ) {
-		$sessionKey = $request->getText( 'wpSessionKey' );
-		$sessionData = $request->getSessionData( UploadBase::SESSION_KEYNAME );
+		$fileKey = $request->getText( 'wpFileKey' ) || $request->getText( 'wpSessionKey' );
 
 		$desiredDestName = $request->getText( 'wpDestFile' );
-		if( !$desiredDestName )
-			$desiredDestName = $request->getText( 'wpUploadFile' );
-		return $this->initialize( $desiredDestName, $sessionKey, $sessionData[$sessionKey] );
+		if( !$desiredDestName ) {
+			$desiredDestName = $request->getText( 'wpUploadFile' ) || $request->getText( 'filename' );
+		}
+		return $this->initialize( $fileKey, $desiredDestName );
+	}
+
+	public function getSourceType() { 
+		return $this->mSourceType; 
 	}
 
 	/**
 	 * File has been previously verified so no need to do so again.
+	 *
+	 * @return bool
 	 */
 	protected function verifyFile() {
 		return true;
 	}
 
-
 	/**
 	 * There is no need to stash the image twice
 	 */
+	public function stashFile( $key = null ) {
+		if ( !empty( $this->mLocalFile ) ) {
+			return $this->mLocalFile;
+		}
+		return parent::stashFile( $key );
+	}
+
+	/**
+	 * Alias for stashFile
+	 */
 	public function stashSession( $key = null ) {
-		if ( !empty( $this->mSessionKey ) )
-			return $this->mSessionKey;
-		return parent::stashSession();
+		return $this->stashFile( $key );
 	}
 
 	/**
@@ -75,9 +118,16 @@ class UploadFromStash extends UploadBase {
 	 * @return success
 	 */
 	public function unsaveUploadedFile() {
-		$repo = RepoGroup::singleton()->getLocalRepo();
-		$success = $repo->freeTemp( $this->mVirtualTempPath );
-		return $success;
+		return $this->stash->removeFile( $this->mFileKey );
+	}
+
+	/**
+	 * Perform the upload, then remove the database record afterward.
+	 */
+	public function performUpload( $comment, $pageText, $watch, $user ) {
+		$rv = parent::performUpload( $comment, $pageText, $watch, $user );
+		$this->unsaveUploadedFile();
+		return $rv;
 	}
 
 }
\ No newline at end of file
diff --git a/includes/upload/UploadFromUrl.php b/includes/upload/UploadFromUrl.php
index c28fd7da..8178988f 100644
--- a/includes/upload/UploadFromUrl.php
+++ b/includes/upload/UploadFromUrl.php
@@ -12,9 +12,13 @@ class UploadFromUrl extends UploadBase {
 	protected $mAsync, $mUrl;
 	protected $mIgnoreWarnings = true;
 
+	protected $mTempPath;
+
 	/**
 	 * Checks if the user is allowed to use the upload-by-URL feature. If the
 	 * user is allowed, pass on permissions checking to the parent.
+	 *
+	 * @param $user User
 	 */
 	public static function isAllowed( $user ) {
 		if ( !$user->isAllowed( 'upload_by_url' ) )
@@ -45,6 +49,9 @@ class UploadFromUrl extends UploadBase {
 
 		$this->mUrl = $url;
 		$this->mAsync = $wgAllowAsyncCopyUploads ? $async : false;
+		if ( $async ) {
+			throw new MWException( 'Asynchronous copy uploads are no longer possible as of r81612.' );
+		}
 
 		$tempPath = $this->mAsync ? null : $this->makeTemporaryFile();
 		# File size and removeTempFile will be filled in later
@@ -53,7 +60,7 @@ class UploadFromUrl extends UploadBase {
 
 	/**
 	 * Entry point for SpecialUpload
-	 * @param $request Object: WebRequest object
+	 * @param $request WebRequest object
 	 */
 	public function initializeFromRequest( &$request ) {
 		$desiredDestName = $request->getText( 'wpDestFile' );
@@ -61,13 +68,13 @@ class UploadFromUrl extends UploadBase {
 			$desiredDestName = $request->getText( 'wpUploadFileURL' );
 		return $this->initialize(
 			$desiredDestName,
-			$request->getVal( 'wpUploadFileURL' ),
+			trim( $request->getVal( 'wpUploadFileURL' ) ),
 			false
 		);
 	}
 
 	/**
-	 * @param $request Object: WebRequest object
+	 * @param $request WebRequest object
 	 */
 	public static function isValidRequest( $request ) {
 		global $wgUser;
@@ -78,6 +85,7 @@ class UploadFromUrl extends UploadBase {
 			&& $wgUser->isAllowed( 'upload_by_url' );
 	}
 
+	public function getSourceType() { return 'url'; }
 
 	public function fetchFile() {
 		if ( !Http::isValidURI( $this->mUrl ) ) {
@@ -137,7 +145,9 @@ class UploadFromUrl extends UploadBase {
 		$this->mRemoveTempFile = true;
 		$this->mFileSize = 0;
 
-		$req = MWHttpRequest::factory( $this->mUrl );
+		$req = MWHttpRequest::factory( $this->mUrl, array(
+			'followRedirects' => true
+		) );
 		$req->setCallback( array( $this, 'saveTempFileChunk' ) );
 		$status = $req->execute();
 
@@ -184,11 +194,11 @@ class UploadFromUrl extends UploadBase {
 	 * Wrapper around the parent function in order to defer checking protection
 	 * until we are sure that the file can actually be uploaded
 	 */
-	public function verifyPermissions( $user ) {
+	public function verifyTitlePermissions( $user ) {
 		if ( $this->mAsync ) {
 			return true;
 		}
-		return parent::verifyPermissions( $user );
+		return parent::verifyTitlePermissions( $user );
 	}
 
 	/**
@@ -207,7 +217,13 @@ class UploadFromUrl extends UploadBase {
 		return parent::performUpload( $comment, $pageText, $watch, $user );
 	}
 
-
+	/**
+	 * @param  $comment
+	 * @param  $pageText
+	 * @param  $watch
+	 * @param  $user User
+	 * @return
+	 */
 	protected function insertJob( $comment, $pageText, $watch, $user ) {
 		$sessionKey = $this->stashSession();
 		$job = new UploadFromUrlJob( $this->getTitle(), array(
@@ -226,5 +242,4 @@ class UploadFromUrl extends UploadBase {
 		return $sessionKey;
 	}
 
-
 }
diff --git a/includes/upload/UploadStash.php b/includes/upload/UploadStash.php
index 1765925d..9304ce5f 100644
--- a/includes/upload/UploadStash.php
+++ b/includes/upload/UploadStash.php
@@ -1,110 +1,190 @@
 <?php
-/** 
+/**
  * UploadStash is intended to accomplish a few things:
  *   - enable applications to temporarily stash files without publishing them to the wiki.
  *      - Several parts of MediaWiki do this in similar ways: UploadBase, UploadWizard, and FirefoggChunkedExtension
  *        And there are several that reimplement stashing from scratch, in idiosyncratic ways. The idea is to unify them all here.
  *	  Mostly all of them are the same except for storing some custom fields, which we subsume into the data array.
- *   - enable applications to find said files later, as long as the session or temp files haven't been purged. 
+ *   - enable applications to find said files later, as long as the db table or temp files haven't been purged.
  *   - enable the uploading user (and *ONLY* the uploading user) to access said files, and thumbnails of said files, via a URL.
- *     We accomplish this by making the session serve as a URL->file mapping, on the assumption that nobody else can access 
- *     the session, even the uploading user. See SpecialUploadStash, which implements a web interface to some files stored this way.
+ *     We accomplish this using a database table, with ownership checking as you might expect. See SpecialUploadStash, which
+ *     implements a web interface to some files stored this way.
  *
+ * UploadStash represents the entire stash of temporary files.
+ * UploadStashFile is a filestore for the actual physical disk files.
+ * UploadFromStash extends UploadBase, and represents a single stashed file as it is moved from the stash to the regular file repository
  */
 class UploadStash {
 
 	// Format of the key for files -- has to be suitable as a filename itself (e.g. ab12cd34ef.jpg)
-	const KEY_FORMAT_REGEX = '/^[\w-]+\.\w*$/';
+	const KEY_FORMAT_REGEX = '/^[\w-\.]+\.\w*$/';
 
-	// repository that this uses to store temp files
-	// public because we sometimes need to get a LocalFile within the same repo.
-	public $repo; 
-	
-	// array of initialized objects obtained from session (lazily initialized upon getFile())
-	private $files = array();  
+	// When a given stashed file can't be loaded, wait for the slaves to catch up.  If they're more than MAX_LAG
+	// behind, throw an exception instead. (at what point is broken better than slow?)
+	const MAX_LAG = 30;
 
-	// TODO: Once UploadBase starts using this, switch to use these constants rather than UploadBase::SESSION*
-	// const SESSION_VERSION = 2;
-	// const SESSION_KEYNAME = 'wsUploadData';
+	// Age of the repository in hours.  That is, after how long will files be assumed abandoned and deleted?
+	const REPO_AGE = 6;
 
 	/**
-	 * Represents the session which contains temporarily stored files.
-	 * Designed to be compatible with the session stashing code in UploadBase (should replace it eventually)
+	 * repository that this uses to store temp files
+	 * public because we sometimes need to get a LocalFile within the same repo.
 	 *
-	 * @param $repo FileRepo: optional -- repo in which to store files. Will choose LocalRepo if not supplied.
+	 * @var LocalRepo
 	 */
-	public function __construct( $repo ) { 
+	public $repo;
+
+	// array of initialized repo objects
+	protected $files = array();
+
+	// cache of the file metadata that's stored in the database
+	protected $fileMetadata = array();
+
+	// fileprops cache
+	protected $fileProps = array();
+
+	// current user
+	protected $user, $userId, $isLoggedIn;
 
+	/**
+	 * Represents a temporary filestore, with metadata in the database.
+	 * Designed to be compatible with the session stashing code in UploadBase (should replace it eventually)
+	 *
+	 * @param $repo FileRepo
+	 */
+	public function __construct( $repo, $user = null ) {
 		// this might change based on wiki's configuration.
 		$this->repo = $repo;
 
-		if ( ! isset( $_SESSION ) ) {
-			throw new UploadStashNotAvailableException( 'no session variable' );
+		// if a user was passed, use it. otherwise, attempt to use the global.
+		// this keeps FileRepo from breaking when it creates an UploadStash object
+		if ( $user ) {
+			$this->user = $user;
+		} else {
+			global $wgUser;
+			$this->user = $wgUser;
 		}
 
-		if ( !isset( $_SESSION[UploadBase::SESSION_KEYNAME] ) ) {
-			$_SESSION[UploadBase::SESSION_KEYNAME] = array();
+		if ( is_object( $this->user ) ) {
+			$this->userId = $this->user->getId();
+			$this->isLoggedIn = $this->user->isLoggedIn();
 		}
-		
 	}
 
 	/**
 	 * Get a file and its metadata from the stash.
-	 * May throw exception if session data cannot be parsed due to schema change, or key not found.
 	 *
-	 * @param $key Integer: key
+	 * @param $key String: key under which file information is stored
+	 * @param $noAuth Boolean (optional) Don't check authentication. Used by maintenance scripts.
 	 * @throws UploadStashFileNotFoundException
-	 * @throws UploadStashBadVersionException
+	 * @throws UploadStashNotLoggedInException
+	 * @throws UploadStashWrongOwnerException
+	 * @throws UploadStashBadPathException
 	 * @return UploadStashFile
 	 */
-	public function getFile( $key ) {
+	public function getFile( $key, $noAuth = false ) {
+
 		if ( ! preg_match( self::KEY_FORMAT_REGEX, $key ) ) {
 			throw new UploadStashBadPathException( "key '$key' is not in a proper format" );
-		} 
- 
-		if ( !isset( $this->files[$key] ) ) {
-			if ( !isset( $_SESSION[UploadBase::SESSION_KEYNAME][$key] ) ) {
-				throw new UploadStashFileNotFoundException( "key '$key' not found in stash" );
+		}
+
+		if ( !$noAuth ) {
+			if ( !$this->isLoggedIn ) {
+				throw new UploadStashNotLoggedInException( __METHOD__ . ' No user is logged in, files must belong to users' );
+			}
+		}
+
+		$dbr = $this->repo->getSlaveDb();
+
+		if ( !isset( $this->fileMetadata[$key] ) ) {
+			// try this first.  if it fails to find the row, check for lag, wait, try again. if its still missing, throw an exception.
+			// this more complex solution keeps things moving for page loads with many requests
+			// (ie. validating image ownership) when replag is high
+			if ( !$this->fetchFileMetadata( $key ) ) {
+				$lag = $dbr->getLag();
+				if ( $lag > 0 && $lag <= self::MAX_LAG ) {
+					// if there's not too much replication lag, just wait for the slave to catch up to our last insert.
+					sleep( ceil( $lag ) );
+				} elseif ( $lag > self::MAX_LAG ) {
+					// that's a lot of lag to introduce into the middle of the UI.
+					throw new UploadStashMaxLagExceededException(
+						'Couldn\'t load stashed file metadata, and replication lag is above threshold: (MAX_LAG=' . self::MAX_LAG . ')'
+					);
+				}
+
+				// now that the waiting has happened, try again
+				$this->fetchFileMetadata( $key );
 			}
 
-			$data = $_SESSION[UploadBase::SESSION_KEYNAME][$key];
-			// guards against PHP class changing while session data doesn't
-			if ($data['version'] !== UploadBase::SESSION_VERSION ) {
-				throw new UploadStashBadVersionException( $data['version'] . " does not match current version " . UploadBase::SESSION_VERSION );
+			if ( !isset( $this->fileMetadata[$key] ) ) {
+				throw new UploadStashFileNotFoundException( "key '$key' not found in stash" );
 			}
-		
-			// separate the stashData into the path, and then the rest of the data
-			$path = $data['mTempPath'];
-			unset( $data['mTempPath'] );
-
-			$file = new UploadStashFile( $this, $this->repo, $path, $key, $data );
-			if ( $file->getSize === 0 ) {
-				throw new UploadStashZeroLengthFileException( "File is zero length" );
+
+			// create $this->files[$key]
+			$this->initFile( $key );
+
+			// fetch fileprops
+			$path = $this->fileMetadata[$key]['us_path'];
+			if ( $this->repo->isVirtualUrl( $path ) ) {
+				$path = $this->repo->resolveVirtualUrl( $path );
 			}
-			$this->files[$key] = $file;
+			$this->fileProps[$key] = File::getPropsFromPath( $path );
+		}
+
+		if ( ! $this->files[$key]->exists() ) {
+			wfDebug( __METHOD__ . " tried to get file at $key, but it doesn't exist\n" );
+			throw new UploadStashBadPathException( "path doesn't exist" );
+		}
 
+		if ( !$noAuth ) {
+			if ( $this->fileMetadata[$key]['us_user'] != $this->userId ) {
+				throw new UploadStashWrongOwnerException( "This file ($key) doesn't belong to the current user." );
+			}
 		}
+
 		return $this->files[$key];
 	}
 
 	/**
-	 * Stash a file in a temp directory and record that we did this in the session, along with other metadata.
-	 * We store data in a flat key-val namespace because that's how UploadBase did it. This also means we have to
-	 * ensure that the key-val pairs in $data do not overwrite other required fields.
+	 * Getter for file metadata.
+	 *
+	 * @param key String: key under which file information is stored
+	 * @return Array
+	 */
+	public function getMetadata ( $key ) {
+		$this->getFile( $key );
+		return $this->fileMetadata[$key];
+	}
+
+	/**
+	 * Getter for fileProps
+	 *
+	 * @param key String: key under which file information is stored
+	 * @return Array
+	 */
+	public function getFileProps ( $key ) {
+		$this->getFile( $key );
+		return $this->fileProps[$key];
+	}
+
+	/**
+	 * Stash a file in a temp directory and record that we did this in the database, along with other metadata.
 	 *
 	 * @param $path String: path to file you want stashed
-	 * @param $data Array: optional, other data you want associated with the file. Do not use 'mTempPath', 'mFileProps', 'mFileSize', or 'version' as keys here
-	 * @param $key String: optional, unique key for this file in this session. Used for directory hashing when storing, otherwise not important
+	 * @param $sourceType String: the type of upload that generated this file (currently, I believe, 'file' or null)
+	 * @param $key String: optional, unique key for this file. Used for directory hashing when storing, otherwise not important
 	 * @throws UploadStashBadPathException
 	 * @throws UploadStashFileException
+	 * @throws UploadStashNotLoggedInException
 	 * @return UploadStashFile: file, or null on failure
 	 */
-	public function stashFile( $path, $data = array(), $key = null ) {
+	public function stashFile( $path, $sourceType = null, $key = null ) {
 		if ( ! file_exists( $path ) ) {
-			wfDebug( "UploadStash: tried to stash file at '$path', but it doesn't exist\n" );
+			wfDebug( __METHOD__ . " tried to stash file at '$path', but it doesn't exist\n" );
 			throw new UploadStashBadPathException( "path doesn't exist" );
 		}
-                $fileProps = File::getPropsFromPath( $path );
+		$fileProps = File::getPropsFromPath( $path );
+		wfDebug( __METHOD__ . " stashing file at '$path'\n" );
 
 		// we will be initializing from some tmpnam files that don't have extensions.
 		// most of MediaWiki assumes all uploaded files have good extensions. So, we fix this.
@@ -115,65 +195,251 @@ class UploadStash {
 				throw new UploadStashFileException( "couldn't rename $path to have a better extension at $pathWithGoodExtension" );
 			}
 			$path = $pathWithGoodExtension;
-		} 
+		}
 
-		// If no key was supplied, use content hash. Also has the nice property of collapsing multiple identical files
-		// uploaded this session, which could happen if uploads had failed.
+		// If no key was supplied, make one.  a mysql insertid would be totally reasonable here, except
+		// that some users of this function might expect to supply the key instead of using the generated one.
 		if ( is_null( $key ) ) {
-			$key = $fileProps['sha1'] . "." . $extension;
+			// some things that when combined will make a suitably unique key.
+			// see: http://www.jwz.org/doc/mid.html
+			list ($usec, $sec) = explode( ' ', microtime() );
+			$usec = substr($usec, 2);
+			$key = wfBaseConvert( $sec . $usec, 10, 36 ) . '.' .
+				wfBaseConvert( mt_rand(), 10, 36 ) . '.'.
+				$this->userId . '.' . 
+				$extension;
 		}
 
+		$this->fileProps[$key] = $fileProps;
+
 		if ( ! preg_match( self::KEY_FORMAT_REGEX, $key ) ) {
 			throw new UploadStashBadPathException( "key '$key' is not in a proper format" );
-		} 
+		}
 
+		wfDebug( __METHOD__ . " key for '$path': $key\n" );
 
 		// if not already in a temporary area, put it there
-		$status = $this->repo->storeTemp( basename( $path ), $path );
+		$storeStatus = $this->repo->storeTemp( basename( $path ), $path );
 
-		if( ! $status->isOK() ) {
+		if ( ! $storeStatus->isOK() ) {
 			// It is a convention in MediaWiki to only return one error per API exception, even if multiple errors
 			// are available. We use reset() to pick the "first" thing that was wrong, preferring errors to warnings.
-			// This is a bit lame, as we may have more info in the $status and we're throwing it away, but to fix it means
+			// This is a bit lame, as we may have more info in the $storeStatus and we're throwing it away, but to fix it means
 			// redesigning API errors significantly.
-			// $status->value just contains the virtual URL (if anything) which is probably useless to the caller
-			$error = reset( $status->getErrorsArray() );
+			// $storeStatus->value just contains the virtual URL (if anything) which is probably useless to the caller
+			$error = $storeStatus->getErrorsArray();
+			$error = reset( $error );
 			if ( ! count( $error ) ) {
-				$error = reset( $status->getWarningsArray() );
+				$error = $storeStatus->getWarningsArray();
+				$error = reset( $error );
 				if ( ! count( $error ) ) {
 					$error = array( 'unknown', 'no error recorded' );
 				}
 			}
 			throw new UploadStashFileException( "error storing file in '$path': " . implode( '; ', $error ) );
 		}
-		$stashPath = $status->value;
-
-		// required info we always store. Must trump any other application info in $data
-		// 'mTempPath', 'mFileSize', and 'mFileProps' are arbitrary names
-		// chosen for compatibility with UploadBase's way of doing this.
-		$requiredData = array( 
-			'mTempPath' => $stashPath,
-			'mFileSize' => $fileProps['size'],
-			'mFileProps' =>	$fileProps,
-			'version' => UploadBase::SESSION_VERSION
+		$stashPath = $storeStatus->value;
+
+		// fetch the current user ID
+		if ( !$this->isLoggedIn ) {
+			throw new UploadStashNotLoggedInException( __METHOD__ . ' No user is logged in, files must belong to users' );
+		}
+
+		// insert the file metadata into the db.
+		wfDebug( __METHOD__ . " inserting $stashPath under $key\n" );
+		$dbw = $this->repo->getMasterDb();
+
+		// select happens on the master so this can all be in a transaction, which
+		// avoids a race condition that's likely with multiple people uploading from the same
+		// set of files
+		$dbw->begin();
+		// first, check to see if it's already there.
+		$row = $dbw->selectRow(
+			'uploadstash',
+			'us_user, us_timestamp',
+			array( 'us_key' => $key ),
+			__METHOD__
+		);
+
+		// The current user can't have this key if:
+		// - the key is owned by someone else and
+		// - the age of the key is less than REPO_AGE
+		if ( is_object( $row ) ) {
+			if ( $row->us_user != $this->userId &&
+				$row->wfTimestamp( TS_UNIX, $row->us_timestamp ) > time() - UploadStash::REPO_AGE * 3600
+			) {
+				$dbw->rollback();
+				throw new UploadStashWrongOwnerException( "Attempting to upload a duplicate of a file that someone else has stashed" );
+			}
+		}
+
+		$this->fileMetadata[$key] = array(
+			'us_user' => $this->userId,
+			'us_key' => $key,
+			'us_orig_path' => $path,
+			'us_path' => $stashPath,
+			'us_size' => $fileProps['size'],
+			'us_sha1' => $fileProps['sha1'],
+			'us_mime' => $fileProps['mime'],
+			'us_media_type' => $fileProps['media_type'],
+			'us_image_width' => $fileProps['width'],
+			'us_image_height' => $fileProps['height'],
+			'us_image_bits' => $fileProps['bits'],
+			'us_source_type' => $sourceType,
+			'us_timestamp' => $dbw->timestamp(),
+			'us_status' => 'finished'
 		);
 
-		// now, merge required info and extra data into the session. (The extra data changes from application to application.
-		// UploadWizard wants different things than say FirefoggChunkedUpload.)
-		wfDebug( __METHOD__ . " storing under $key\n" );
-		$_SESSION[UploadBase::SESSION_KEYNAME][$key] = array_merge( $data, $requiredData );
-		
+		// if a row exists but previous checks on it passed, let the current user take over this key.
+		$dbw->replace(
+			'uploadstash',
+			'us_key',
+			$this->fileMetadata[$key],
+			__METHOD__
+		);
+		$dbw->commit();
+
+		// store the insertid in the class variable so immediate retrieval (possibly laggy) isn't necesary.
+		$this->fileMetadata[$key]['us_id'] = $dbw->insertId();
+
+		# create the UploadStashFile object for this file.
+		$this->initFile( $key );
+
 		return $this->getFile( $key );
 	}
 
 	/**
+	 * Remove all files from the stash.
+	 * Does not clean up files in the repo, just the record of them.
+	 *
+	 * @throws UploadStashNotLoggedInException
+	 * @return boolean: success
+	 */
+	public function clear() {
+		if ( !$this->isLoggedIn ) {
+			throw new UploadStashNotLoggedInException( __METHOD__ . ' No user is logged in, files must belong to users' );
+		}
+
+		wfDebug( __METHOD__ . " clearing all rows for user $userId\n" );
+		$dbw = $this->repo->getMasterDb();
+		$dbw->delete(
+			'uploadstash',
+			array( 'us_user' => $this->userId ),
+			__METHOD__
+		);
+
+		# destroy objects.
+		$this->files = array();
+		$this->fileMetadata = array();
+
+		return true;
+	}
+
+	/**
+	 * Remove a particular file from the stash.  Also removes it from the repo.
+	 *
+	 * @throws UploadStashNotLoggedInException
+	 * @throws UploadStashWrongOwnerException
+	 * @return boolean: success
+	 */
+	public function removeFile( $key ) {
+		if ( !$this->isLoggedIn ) {
+			throw new UploadStashNotLoggedInException( __METHOD__ . ' No user is logged in, files must belong to users' );
+		}
+
+		$dbw = $this->repo->getMasterDb();
+
+		// this is a cheap query. it runs on the master so that this function still works when there's lag.
+		// it won't be called all that often.
+		$row = $dbw->selectRow(
+			'uploadstash',
+			'us_user',
+			array( 'us_key' => $key ),
+			__METHOD__
+		);
+
+		if( !$row ) {
+			throw new UploadStashNoSuchKeyException( "No such key ($key), cannot remove" );
+		}
+
+		if ( $row->us_user != $this->userId ) {
+			throw new UploadStashWrongOwnerException( "Can't delete: the file ($key) doesn't belong to this user." );
+		}
+
+		return $this->removeFileNoAuth( $key );
+	}
+
+
+	/**
+	 * Remove a file (see removeFile), but doesn't check ownership first.
+	 *
+	 * @return boolean: success
+	 */
+	public function removeFileNoAuth( $key ) {
+		wfDebug( __METHOD__ . " clearing row $key\n" );
+
+		$dbw = $this->repo->getMasterDb();
+
+		// this gets its own transaction since it's called serially by the cleanupUploadStash maintenance script
+		$dbw->begin();
+		$dbw->delete(
+			'uploadstash',
+			array( 'us_key' => $key ),
+			__METHOD__
+		);
+		$dbw->commit();
+
+		// TODO: look into UnregisteredLocalFile and find out why the rv here is sometimes wrong (false when file was removed)
+		// for now, ignore.
+		$this->files[$key]->remove();
+
+		unset( $this->files[$key] );
+		unset( $this->fileMetadata[$key] );
+
+		return true;
+	}
+
+	/**
+	 * List all files in the stash.
+	 *
+	 * @throws UploadStashNotLoggedInException
+	 * @return Array
+	 */
+	public function listFiles() {
+		if ( !$this->isLoggedIn ) {
+			throw new UploadStashNotLoggedInException( __METHOD__ . ' No user is logged in, files must belong to users' );
+		}
+
+		$dbr = $this->repo->getSlaveDb();
+		$res = $dbr->select(
+			'uploadstash',
+			'us_key',
+			array( 'us_key' => $key ),
+			__METHOD__
+		);
+
+		if ( !is_object( $res ) || $res->numRows() == 0 ) {
+			// nothing to do.
+			return false;
+		}
+
+		// finish the read before starting writes.
+		$keys = array();
+		foreach ( $res as $row ) {
+			array_push( $keys, $row->us_key );
+		}
+
+		return $keys;
+	}
+
+	/**
 	 * Find or guess extension -- ensuring that our extension matches our mime type.
-	 * Since these files are constructed from php tempnames they may not start off 
+	 * Since these files are constructed from php tempnames they may not start off
 	 * with an extension.
-	 * XXX this is somewhat redundant with the checks that ApiUpload.php does with incoming 
+	 * XXX this is somewhat redundant with the checks that ApiUpload.php does with incoming
 	 * uploads versus the desired filename. Maybe we can get that passed to us...
 	 */
-	public static function getExtensionForPath( $path ) { 	
+	public static function getExtensionForPath( $path ) {
 		// Does this have an extension?
 		$n = strrpos( $path, '.' );
 		$extension = null;
@@ -184,8 +450,8 @@ class UploadStash {
 			$magic = MimeMagic::singleton();
 			$mimeType = $magic->guessMimeType( $path );
 			$extensions = explode( ' ', MimeMagic::singleton()->getExtensionsForType( $mimeType ) );
-			if ( count( $extensions ) ) { 
-				$extension = $extensions[0];	
+			if ( count( $extensions ) ) {
+				$extension = $extensions[0];
 			}
 		}
 
@@ -196,52 +462,103 @@ class UploadStash {
 		return File::normalizeExtension( $extension );
 	}
 
+	/**
+	 * Helper function: do the actual database query to fetch file metadata.
+	 *
+	 * @param $key String: key
+	 * @return boolean
+	 */
+	protected function fetchFileMetadata( $key ) {
+		// populate $fileMetadata[$key]
+		$dbr = $this->repo->getSlaveDb();
+		$row = $dbr->selectRow(
+			'uploadstash',
+			'*',
+			array( 'us_key' => $key ),
+			__METHOD__
+		);
+
+		if ( !is_object( $row ) ) {
+			// key wasn't present in the database. this will happen sometimes.
+			return false;
+		}
+
+		$this->fileMetadata[$key] = array(
+			'us_user' => $row->us_user,
+			'us_key' => $row->us_key,
+			'us_orig_path' => $row->us_orig_path,
+			'us_path' => $row->us_path,
+			'us_size' => $row->us_size,
+			'us_sha1' => $row->us_sha1,
+			'us_mime' => $row->us_mime,
+			'us_media_type' => $row->us_media_type,
+			'us_image_width' => $row->us_image_width,
+			'us_image_height' => $row->us_image_height,
+			'us_image_bits' => $row->us_image_bits,
+			'us_source_type' => $row->us_source_type,
+			'us_timestamp' => $row->us_timestamp,
+			'us_status' => $row->us_status
+		);
+
+		return true;
+	}
+
+	/**
+	 * Helper function: Initialize the UploadStashFile for a given file.
+	 *
+	 * @param $path String: path to file
+	 * @param $key String: key under which to store the object
+	 * @throws UploadStashZeroLengthFileException
+	 * @return bool
+	 */
+	protected function initFile( $key ) {
+		$file = new UploadStashFile( $this->repo, $this->fileMetadata[$key]['us_path'], $key );
+		if ( $file->getSize() === 0 ) {
+			throw new UploadStashZeroLengthFileException( "File is zero length" );
+		}
+		$this->files[$key] = $file;
+		return true;
+	}
 }
 
 class UploadStashFile extends UnregisteredLocalFile {
-	private $sessionStash;
-	private $sessionKey;
-	private $sessionData;
+	private $fileKey;
 	private $urlName;
+	protected $url;
 
 	/**
 	 * A LocalFile wrapper around a file that has been temporarily stashed, so we can do things like create thumbnails for it
 	 * Arguably UnregisteredLocalFile should be handling its own file repo but that class is a bit retarded currently
 	 *
-	 * @param $stash UploadStash: useful for obtaining config, stashing transformed files
-	 * @param $repo FileRepo: repository where we should find the path
+	 * @param $repo FSRepo: repository where we should find the path
 	 * @param $path String: path to file
 	 * @param $key String: key to store the path and any stashed data under
-	 * @param $data String: any other data we want stored with this file
 	 * @throws UploadStashBadPathException
 	 * @throws UploadStashFileNotFoundException
 	 */
-	public function __construct( $stash, $repo, $path, $key, $data ) { 
-		$this->sessionStash = $stash;
-		$this->sessionKey = $key;
-		$this->sessionData = $data;
+	public function __construct( $repo, $path, $key ) {
+		$this->fileKey = $key;
 
 		// resolve mwrepo:// urls
 		if ( $repo->isVirtualUrl( $path ) ) {
-			$path = $repo->resolveVirtualUrl( $path );	
-		}
+			$path = $repo->resolveVirtualUrl( $path );
+		} else {
 
-		// check if path appears to be sane, no parent traversals, and is in this repo's temp zone.
-		$repoTempPath = $repo->getZonePath( 'temp' );
-		if ( ( ! $repo->validateFilename( $path ) ) || 
-				( strpos( $path, $repoTempPath ) !== 0 ) ) {
-			wfDebug( "UploadStash: tried to construct an UploadStashFile from a file that should already exist at '$path', but path is not valid\n" );
-			throw new UploadStashBadPathException( 'path is not valid' );
-		}
+			// check if path appears to be sane, no parent traversals, and is in this repo's temp zone.
+			$repoTempPath = $repo->getZonePath( 'temp' );
+			if ( ( ! $repo->validateFilename( $path ) ) ||
+					( strpos( $path, $repoTempPath ) !== 0 ) ) {
+				wfDebug( "UploadStash: tried to construct an UploadStashFile from a file that should already exist at '$path', but path is not valid\n" );
+				throw new UploadStashBadPathException( 'path is not valid' );
+			}
 
-		// check if path exists! and is a plain file.
-		if ( ! $repo->fileExists( $path, FileRepo::FILES_ONLY ) ) {
-			wfDebug( "UploadStash: tried to construct an UploadStashFile from a file that should already exist at '$path', but path is not found\n" );
-			throw new UploadStashFileNotFoundException( 'cannot find path, or not a plain file' );
+			// check if path exists! and is a plain file.
+			if ( ! $repo->fileExists( $path, FileRepo::FILES_ONLY ) ) {
+				wfDebug( "UploadStash: tried to construct an UploadStashFile from a file that should already exist at '$path', but path is not found\n" );
+				throw new UploadStashFileNotFoundException( 'cannot find path, or not a plain file' );
+			}
 		}
 
-			
-
 		parent::__construct( false, $repo, $path, false );
 
 		$this->name = basename( $this->path );
@@ -261,13 +578,13 @@ class UploadStashFile extends UnregisteredLocalFile {
 
 	/**
 	 * Get the path for the thumbnail (actually any transformation of this file)
-	 * The actual argument is the result of thumbName although we seem to have 
+	 * The actual argument is the result of thumbName although we seem to have
 	 * buggy code elsewhere that expects a boolean 'suffix'
 	 *
 	 * @param $thumbName String: name of thumbnail (e.g. "120px-123456.jpg" ), or false to just get the path
 	 * @return String: path thumbnail should take on filesystem, or containing directory if thumbname is false
 	 */
-	public function getThumbPath( $thumbName = false ) { 
+	public function getThumbPath( $thumbName = false ) {
 		$path = dirname( $this->path );
 		if ( $thumbName !== false ) {
 			$path .= "/$thumbName";
@@ -276,71 +593,49 @@ class UploadStashFile extends UnregisteredLocalFile {
 	}
 
 	/**
-	 * Return the file/url base name of a thumbnail with the specified parameters
+	 * Return the file/url base name of a thumbnail with the specified parameters.
+	 * We override this because we want to use the pretty url name instead of the
+	 * ugly file name.
 	 *
 	 * @param $params Array: handler-specific parameters
 	 * @return String: base name for URL, like '120px-12345.jpg', or null if there is no handler
 	 */
 	function thumbName( $params ) {
-		return $this->getParamThumbName( $this->getUrlName(), $params );
-	}
-
-
-	/**
-	 * Given the name of the original, i.e. Foo.jpg, and scaling parameters, returns filename with appropriate extension
-	 * This is abstracted from getThumbName because we also use it to calculate the thumbname the file should have on 
-	 * remote image scalers	
-	 *
-	 * @param String $urlName: A filename, like MyMovie.ogx
-	 * @param Array $parameters: scaling parameters, like array( 'width' => '120' );
-	 * @return String|null parameterized thumb name, like 120px-MyMovie.ogx.jpg, or null if no handler found
-	 */
-	function getParamThumbName( $urlName, $params ) {
-		if ( !$this->getHandler() ) {
-			return null;
-		}
-		$extension = $this->getExtension();
-		list( $thumbExt, ) = $this->handler->getThumbType( $extension, $this->getMimeType(), $params );
-		$thumbName = $this->getHandler()->makeParamString( $params ) . '-' . $urlName;
-		if ( $thumbExt != $extension ) {
-			$thumbName .= ".$thumbExt";
-		}
-		return $thumbName;
+		return $this->generateThumbName( $this->getUrlName(), $params );
 	}
 
 	/**
 	 * Helper function -- given a 'subpage', return the local URL e.g. /wiki/Special:UploadStash/subpage
 	 * @param {String} $subPage
-	 * @return {String} local URL for this subpage in the Special:UploadStash space. 
+	 * @return {String} local URL for this subpage in the Special:UploadStash space.
 	 */
 	private function getSpecialUrl( $subPage ) {
 		return SpecialPage::getTitleFor( 'UploadStash', $subPage )->getLocalURL();
 	}
 
-
-	/** 
-	 * Get a URL to access the thumbnail 
-	 * This is required because the model of how files work requires that 
+	/**
+	 * Get a URL to access the thumbnail
+	 * This is required because the model of how files work requires that
 	 * the thumbnail urls be predictable. However, in our model the URL is not based on the filename
-	 * (that's hidden in the session)
+	 * (that's hidden in the db)
 	 *
 	 * @param $thumbName String: basename of thumbnail file -- however, we don't want to use the file exactly
 	 * @return String: URL to access thumbnail, or URL with partial path
 	 */
-	public function getThumbUrl( $thumbName = false ) { 
+	public function getThumbUrl( $thumbName = false ) {
 		wfDebug( __METHOD__ . " getting for $thumbName \n" );
 		return $this->getSpecialUrl( 'thumb/' . $this->getUrlName() . '/' . $thumbName );
 	}
 
-	/** 
+	/**
 	 * The basename for the URL, which we want to not be related to the filename.
 	 * Will also be used as the lookup key for a thumbnail file.
 	 *
 	 * @return String: base url name, like '120px-123456.jpg'
 	 */
-	public function getUrlName() { 
+	public function getUrlName() {
 		if ( ! $this->urlName ) {
-			$this->urlName = $this->sessionKey;
+			$this->urlName = $this->fileKey;
 		}
 		return $this->urlName;
 	}
@@ -359,23 +654,22 @@ class UploadStashFile extends UnregisteredLocalFile {
 	}
 
 	/**
-	 * Parent classes use this method, for no obvious reason, to return the path (relative to wiki root, I assume). 
+	 * Parent classes use this method, for no obvious reason, to return the path (relative to wiki root, I assume).
 	 * But with this class, the URL is unrelated to the path.
 	 *
 	 * @return String: url
 	 */
-	public function getFullUrl() { 
+	public function getFullUrl() {
 		return $this->getUrl();
 	}
 
-
 	/**
-	 * Getter for session key (the session-unique id by which this file's location & metadata is stored in the session)
+	 * Getter for file key (the unique id by which this file's location & metadata is stored in the db)
 	 *
-	 * @return String: session key
+	 * @return String: file key
 	 */
-	public function getSessionKey() {
-		return $this->sessionKey;
+	public function getFileKey() {
+		return $this->fileKey;
 	}
 
 	/**
@@ -383,15 +677,26 @@ class UploadStashFile extends UnregisteredLocalFile {
 	 * @return Status: success
 	 */
 	public function remove() {
+		if ( !$this->repo->fileExists( $this->path, FileRepo::FILES_ONLY ) ) {
+			// Maybe the file's already been removed? This could totally happen in UploadBase.
+			return true;
+		}
+
 		return $this->repo->freeTemp( $this->path );
 	}
 
+	public function exists() {
+		return $this->repo->fileExists( $this->path, FileRepo::FILES_ONLY );
+	}
+
 }
 
 class UploadStashNotAvailableException extends MWException {};
 class UploadStashFileNotFoundException extends MWException {};
 class UploadStashBadPathException extends MWException {};
-class UploadStashBadVersionException extends MWException {};
 class UploadStashFileException extends MWException {};
 class UploadStashZeroLengthFileException extends MWException {};
-
+class UploadStashNotLoggedInException extends MWException {};
+class UploadStashWrongOwnerException extends MWException {};
+class UploadStashMaxLagExceededException extends MWException {};
+class UploadStashNoSuchKeyException extends MWException {};