@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/net/SharedObject.ts

@@ -0,0 +1,365 @@
+import { ASObject } from '@awayfl/avm2';
+import { notImplemented, warning, StringUtilities } from '@awayfl/swf-loader';
+import { axCoerceString, ObjectEncoding, AMF3, transformASValueToJS, transformJSValueToAS } from '@awayfl/avm2';
+import { ByteArray } from '../utils/ByteArray';
+import { SecurityDomain } from '../SecurityDomain';
+
+export const AWAY_SO_VERSION = 3;
+export const AWAY_SO_MAGIC = 'AWAY';
+export const AWAY_SO_HEADER_SIZE = AWAY_SO_MAGIC.length + 2; // magic, version, coma
+
+interface IStorage {
+	getItem(key: string): string;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+}
+
+let _sharedObjectStorage: IStorage;
+
+class VirtualStorage implements IStorage {
+	_values: StringMap<string> = {};
+	_realStorage: IStorage = null;
+
+	getItem(key: string) {
+		if (this._realStorage) {
+			this._values[key] = this._realStorage.getItem(key);
+		}
+		return this._values[key];
+	}
+
+	setItem(key: string, value: string) {
+		if (this._realStorage) {
+			this._realStorage.setItem(key, value);
+		}
+		this._values[key] = value;
+	}
+
+	removeItem(key: string) {
+		if (this._realStorage) {
+			this._realStorage.removeItem(key);
+		}
+		delete this._values[key];
+	}
+}
+
+export function getSharedObjectStorage(): IStorage {
+	if (!_sharedObjectStorage) {
+		_sharedObjectStorage = new VirtualStorage();
+
+		if (typeof Storage !== 'undefined') {
+			try {
+				(_sharedObjectStorage as VirtualStorage)._realStorage = window.localStorage;
+			} catch (e) {
+				console.warn('[Shared Storage] ', e);
+			}
+		}
+	}
+	return _sharedObjectStorage;
+}
+
+export class SharedObjectDebug {
+	public static _lastRawData: any = null;
+	public static _lastDecodedData: any = null;
+
+	public static decodedData() {
+		if (!USED_SEC) {
+			throw 'Can\'t decode without security context';
+		}
+
+		const store = getSharedObjectStorage() as VirtualStorage;
+		const raw = {};
+		const dec = {};
+
+		for (const key in store._values) {
+			const d = store._values[key];
+
+			if (d !== null) {
+				raw[key] = SharedObject.tryDecodeData(store._values[key]).data;
+				dec[key] = transformASValueToJS(USED_SEC, raw[key], true);
+			} else {
+				raw[key] = dec[key] = null;
+			}
+		}
+
+		this._lastDecodedData = dec;
+		this._lastRawData = raw;
+
+		return dec;
+	}
+
+	public static encodeAndApplyData(): any {
+		if (!this._lastRawData) {
+			throw 'Need call decode before encode for detecting model';
+		}
+
+		const newRaw = {};
+
+		for (const key in this._lastRawData) {
+			if (typeof this._lastDecodedData[key] === undefined) {
+
+				newRaw[key] = this._lastRawData[key];
+				continue;
+			}
+
+			newRaw[key] = transformJSValueToAS(USED_SEC, this._lastDecodedData[key], true);
+		}
+
+		const so = getSharedObjectStorage();
+
+		for (const key in newRaw) {
+			if (newRaw[key] !== null) {
+				so.setItem(key, SharedObject.tryEncodeData(newRaw[key]));
+			}
+		}
+
+		return newRaw;
+	}
+}
+
+//@ts-ignore
+window._AWAY_DEBUG_STORAGE = SharedObjectDebug;
+window.addEventListener('unload', () => {
+	SharedObject.closeAll();
+});
+window.addEventListener('blur', () => {
+	SharedObject.flushAll();
+});
+
+let USED_SEC: any = undefined;
+export class SharedObject extends ASObject {
+	public awaySOVersion = 1; // legacy
+	private _data: ASObject;
+	private _object_name: string;
+
+	static axClass: typeof SharedObject;
+	static _sharedObjects: Record<string, SharedObject> = {};
+
+	constructor() {
+		super();
+	}
+
+	static get defaultObjectEncoding(): number /*uint*/ {
+		notImplemented('public flash.net.SharedObject::static defaultObjectEncoding');
+		return;
+	}
+
+	static set defaultObjectEncoding(version: number /*uint*/) {
+		notImplemented('public flash.net.SharedObject::static defaultObjectEncoding');
+		return;
+	}
+
+	public static deleteAll(url: string): number /*int*/ {
+		notImplemented('public flash.net.SharedObject::static deleteAll');
+		return;
+	}
+
+	public static getDiskUsage(url: string): number /*int*/ {
+		notImplemented('public flash.net.SharedObject::static getDiskUsage');
+		return 0;
+	}
+
+	public _path: string;
+	public _fps: number;
+	public _objectEncoding;
+	private static _defaultObjectEncoding = ObjectEncoding.DEFAULT;
+
+	/* internal */ static tryDecodeData(data: string): {data: any, version: number} {
+		let version = 1;
+
+		if (data.indexOf(AWAY_SO_MAGIC) > -1) {
+			version = +data[AWAY_SO_MAGIC.length];
+			data = data.substring(AWAY_SO_HEADER_SIZE);
+		}
+
+		const bytes = StringUtilities.decodeRestrictedBase64ToBytes(data);
+		const serializedData = new ByteArray(bytes.length);
+		(<any>serializedData).sec = this.sec || USED_SEC;
+
+		serializedData.setArrayBuffer(bytes.buffer);
+
+		return {
+			data: AMF3.read(<any>serializedData),
+			version: version
+		};
+	}
+
+	/* internal */ static tryEncodeData(data: any): string {
+		const serializedData = new ByteArray();
+		(<any>serializedData).sec = this.sec || USED_SEC;
+
+		AMF3.write(<any>serializedData, data);
+
+		const bytes = new Uint8Array(serializedData.arraybytes, 0, serializedData.length);
+
+		return StringUtilities.base64EncodeBytes(bytes);
+	}
+
+	public static getLocal(name: string, localPath?: string, secure?: boolean): SharedObject {
+		USED_SEC = this.sec;
+
+		name = axCoerceString(name);
+		localPath = axCoerceString(localPath);
+		secure = !!secure;
+
+		const path = (localPath || '') + '/' + name;
+
+		if (SharedObject._sharedObjects[path]) {
+			return SharedObject._sharedObjects[path];
+		}
+
+		const encodedData = getSharedObjectStorage().getItem(path);
+		const encoding = this._defaultObjectEncoding;
+
+		let data;
+		let version = AWAY_SO_VERSION;
+
+		if (encodedData) {
+			try {
+				const res = SharedObject.tryDecodeData(encodedData);
+				data = res.data;
+				version = res.version;
+			} catch (e) {
+				warning('Error encountered while decoding LocalStorage entry. Resetting data.');
+			}
+			if (!data || typeof data !== 'object') {
+				data = this.sec.createObject();
+			}
+		} else {
+			data = this.sec.createObject();
+		}
+
+		const so: SharedObject = new (<SecurityDomain> this.sec).flash.net.SharedObject();
+
+		so._path = path;
+		so._objectEncoding = encoding;
+		so._data = data;
+		so.awaySOVersion = version;
+
+		SharedObject._sharedObjects[path] = so;
+		return so;
+	}
+
+	public static getRemote(name: string, remotePath?: string, persistence?: boolean, secure?: boolean): SharedObject {
+		return new (<SecurityDomain> this.sec).flash.net.SharedObject();
+	}
+
+	public static closeAll() {
+		for (const key in SharedObject._sharedObjects) {
+			if (SharedObject._sharedObjects[key]) {
+				SharedObject._sharedObjects[key].close();
+			}
+		}
+	}
+
+	public static flushAll() {
+		for (const key in SharedObject._sharedObjects) {
+			if (SharedObject._sharedObjects[key]) {
+				SharedObject._sharedObjects[key].flush();
+			}
+		}
+	}
+
+	public flush(minDiskSpace: number = 0): void {
+		// Check if the object is empty. If it is, don't create a stored object if one doesn't exist.
+		let isEmpty = true;
+		for (const key in this._data) {
+			if (this._data.hasOwnProperty(key)) {
+				isEmpty = false;
+				break;
+			}
+		}
+
+		if (isEmpty && !getSharedObjectStorage().getItem(this._path)) {
+			return;
+		}
+
+		USED_SEC = this.sec;
+		const encoded =
+			AWAY_SO_MAGIC +
+			AWAY_SO_VERSION.toFixed(0) + ',' +
+			SharedObject.tryEncodeData(this._data);
+
+		getSharedObjectStorage().setItem(this._path, encoded);
+	}
+
+	public get data(): ASObject {
+		return this._data;
+	}
+
+	public set data(object: ASObject) {
+		this._data = object;
+	}
+
+	public get objectEncoding(): number /*uint*/ {
+		notImplemented('public flash.net.SharedObject::get objectEncoding');
+		return;
+	}
+
+	public set objectEncoding(version: number /*uint*/) {
+		notImplemented('public flash.net.SharedObject::set objectEncoding');
+		return;
+	}
+
+	public get client(): ASObject {
+		notImplemented('public flash.net.SharedObject::get client');
+		return;
+		// return this._client;
+	}
+
+	public set client(object: ASObject) {
+		notImplemented('public flash.net.SharedObject::set client');
+		return;
+		// this._client = object;
+	}
+
+	public setDirty(propertyName: string): void {
+		notImplemented('public flash.net.SharedObject::setDirty');
+		return;
+	}
+
+	public connect(myConnection: any, params: string = null): void {
+		notImplemented('public flash.net.SharedObject::connect');
+		return;
+	}
+
+	public send(): void {
+		notImplemented('public flash.net.SharedObject::send');
+		return;
+	}
+
+	/**
+	 * Closed and flushed SO
+	 * @see https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/SharedObject.html#close()
+	 */
+	public close(): void {
+		// should run flush when close is requested
+		this.flush();
+		delete SharedObject._sharedObjects[this._path];
+	}
+
+	/**
+	 * Clear object
+	 * @see https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/SharedObject.html#clear()
+	 */
+	public clear(): void {
+		this._data = this.sec.createObject();
+		// should run flush to overwrite a data to empty, but we only remove key
+		// this is look like simmilar
+		getSharedObjectStorage().removeItem(this._path);
+		delete SharedObject._sharedObjects[this._path];
+	}
+
+	public get size(): number {
+		return getSharedObjectStorage().getItem(this._path)?.length || 0;
+	}
+
+	public set fps(updatesPerSecond: number) {
+		notImplemented('public flash.net.SharedObject::set fps');
+		return;
+	}
+
+	public setProperty(propertyName: string, value: any = null): void {
+		notImplemented('public flash.net.SharedObject::setProperty');
+		return;
+	}
+}

package/lib/net/Socket.ts

@@ -0,0 +1,251 @@
+import { release, somewhatImplemented, notImplemented } from '@awayfl/swf-loader';
+import { axCoerceString } from '@awayfl/avm2';
+import { Errors } from '@awayfl/avm2';
+import { EventDispatcher } from '../events/EventDispatcher';
+import { IDataInput } from '../utils/IDataInput';
+import { IDataOutput } from '../utils/IDataOutput';
+import { ByteArray } from '../utils/ByteArray';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: Socket
+
+export class Socket extends EventDispatcher implements IDataInput, IDataOutput {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // ["timeout", "timeout", "connect", "close"];
+
+	constructor (host: string = null, port: number /*int*/ = 0) {
+		super(undefined);
+		host = axCoerceString(host); port = port | 0;
+	}
+
+	// JS -> AS Bindings
+
+	timeout: number /*uint*/;
+	connect: (host: string, port: number /*int*/) => void;
+	close: () => void;
+
+	// AS -> JS Bindings
+
+	// _timeout: number /*uint*/;
+	// _bytesAvailable: number /*uint*/;
+	// _connected: boolean;
+	// _objectEncoding: number /*uint*/;
+	// _endian: string;
+	// _bytesPending: number /*uint*/;
+	get bytesAvailable(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get bytesAvailable');
+		return 0;
+		// return this._bytesAvailable;
+	}
+
+	get connected(): boolean {
+		release || notImplemented('public flash.net.Socket::get connected');
+		return false;
+		// return this._connected;
+	}
+
+	get objectEncoding(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get objectEncoding');
+		return 0;
+		// return this._objectEncoding;
+	}
+
+	set objectEncoding(version: number /*uint*/) {
+		version = version >>> 0;
+		release || notImplemented('public flash.net.Socket::set objectEncoding');
+		// this._objectEncoding = version;
+	}
+
+	get endian(): string {
+		release || notImplemented('public flash.net.Socket::get endian');
+		return '';
+		// return this._endian;
+	}
+
+	set endian(type: string) {
+		type = axCoerceString(type);
+		release || notImplemented('public flash.net.Socket::set endian');
+		// this._endian = type;
+	}
+
+	get bytesPending(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get bytesPending');
+		return 0;
+		// return this._bytesPending;
+	}
+
+	readBytes(bytes: ByteArray, offset: number /*uint*/ = 0, length: number /*uint*/ = 0): void {
+		bytes = bytes; offset = offset >>> 0; length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::readBytes');
+		return;
+	}
+
+	writeBytes(bytes: ByteArray, offset: number /*uint*/ = 0, length: number /*uint*/ = 0): void {
+		bytes = bytes; offset = offset >>> 0; length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::writeBytes'); return;
+	}
+
+	writeBoolean(value: boolean): void {
+		value = !!value;
+		release || notImplemented('public flash.net.Socket::writeBoolean'); return;
+	}
+
+	writeByte(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeByte'); return;
+	}
+
+	writeShort(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeShort'); return;
+	}
+
+	writeInt(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeInt'); return;
+	}
+
+	writeUnsignedInt(value: number /*uint*/): void {
+		value = value >>> 0;
+		release || notImplemented('public flash.net.Socket::writeUnsignedInt'); return;
+	}
+
+	writeFloat(value: number): void {
+		value = +value;
+		release || notImplemented('public flash.net.Socket::writeFloat'); return;
+	}
+
+	writeDouble(value: number): void {
+		value = +value;
+		release || notImplemented('public flash.net.Socket::writeDouble'); return;
+	}
+
+	writeMultiByte(value: string, charSet: string): void {
+		value = axCoerceString(value); charSet = axCoerceString(charSet);
+		release || notImplemented('public flash.net.Socket::writeMultiByte'); return;
+	}
+
+	writeUTF(value: string): void {
+		value = axCoerceString(value);
+		release || notImplemented('public flash.net.Socket::writeUTF'); return;
+	}
+
+	writeUTFBytes(value: string): void {
+		value = axCoerceString(value);
+		release || notImplemented('public flash.net.Socket::writeUTFBytes'); return;
+	}
+
+	readBoolean(): boolean {
+		release || notImplemented('public flash.net.Socket::readBoolean');
+		return false;
+	}
+
+	readByte(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readByte');
+		return 0;
+	}
+
+	readUnsignedByte(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedByte');
+		return 0;
+	}
+
+	readShort(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readShort');
+		return 0;
+	}
+
+	readUnsignedShort(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedShort');
+		return 0;
+	}
+
+	readInt(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readInt');
+		return 0;
+	}
+
+	readUnsignedInt(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedInt');
+		return 0;
+	}
+
+	readFloat(): number {
+		release || notImplemented('public flash.net.Socket::readFloat');
+		return 0;
+	}
+
+	readDouble(): number {
+		release || notImplemented('public flash.net.Socket::readDouble');
+		return 0;
+	}
+
+	readMultiByte(length: number /*uint*/, charSet: string): string {
+		length = length >>> 0; charSet = axCoerceString(charSet);
+		release || notImplemented('public flash.net.Socket::readMultiByte');
+		return '';
+	}
+
+	readUTF(): string {
+		release || notImplemented('public flash.net.Socket::readUTF');
+		return '';
+	}
+
+	readUTFBytes(length: number /*uint*/): string {
+		length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::readUTFBytes');
+		return '';
+	}
+
+	flush(): void {
+		release || notImplemented('public flash.net.Socket::flush');
+	}
+
+	writeObject(object: any): void {
+
+		release || notImplemented('public flash.net.Socket::writeObject');
+	}
+
+	readObject(): any {
+		release || notImplemented('public flash.net.Socket::readObject');
+		return;
+	}
+
+	internalGetSecurityErrorMessage(host, port): string {
+		host = axCoerceString(host); port |= 0;
+		release || somewhatImplemented('flash.net.Socket::internalGetSecurityErrorMessage');
+		return 'SecurityErrorEvent';
+	}
+
+	internalConnect(host, port) {
+		host = axCoerceString(host); port |= 0;
+		release || somewhatImplemented('flash.net.Socket::internalConnect');
+		this.sec.throwError('SecurityError', Errors.SocketConnectError, host, port);
+	}
+
+	didFailureOccur(): boolean {
+		release || somewhatImplemented('flash.net.Socket::didFailureOccur');
+		return true;
+	}
+}