No OneTemporary
Actions

Authored By

Unknown

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/input/sdl/joystick.cpp b/util/input/sdl/joystick.cpp
	index 9cb68a80..ff15a4d9 100644
	--- a/util/input/sdl/joystick.cpp
	+++ b/util/input/sdl/joystick.cpp
	@@ -1,678 +1,678 @@
	#ifdef USE_SDL

	#include <SDL.h>
	#include "joystick.h"
	#include "util/debug.h"
	#include <string>
	#include <vector>

	using std::string;
	using std::vector;

	class ButtonMapping{
	public:
	ButtonMapping(){
	}

	virtual ~ButtonMapping(){
	}

	virtual int toNative(int button) = 0;
	virtual int fromNative(int button) = 0;
	virtual Joystick::Key toKey(int button) = 0;
	virtual void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events) = 0;
	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events) = 0;
	};

	class DefaultButtonMapping: public ButtonMapping {
	public:
	int toNative(int button){
	return button;
	}

	int fromNative(int button){
	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case 0: return Joystick::Button1;
	case 1: return Joystick::Button2;
	case 2: return Joystick::Button3;
	case 3: return Joystick::Button4;
	case 4: return Joystick::Quit;
	case 5: return Joystick::Button5;
	case 6: return Joystick::Button6;
	default: return Joystick::Invalid;
	}
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	/* FIXME */
	/*
	if (axis == 0){
	if (motion < 0){
	return Joystick::Left;
	} else if (motion > 0){
	return Joystick::Right;
	}
	} else if (axis == 1){
	if (motion < 0){
	return Joystick::Up;
	} else if (motion > 0){
	return Joystick::Down;
	}
	}
	*/

	}
	};

	/* used when a ps3 controller is plugged into a usb port of a normal pc */
	class Playstation3Controller: public ButtonMapping {
	public:
	enum Buttons{
	Cross = 14,
	Circle = 13,
	Triangle = 12,
	Square = 15,
	Start = 3,
	Select = 0,
	Up = 4,
	Left = 7,
	Down = 6,
	Right = 5,
	Stick1 = 1,
	Stick2 = 2,
	L2 = 8,
	L1 = 10,
	R2 = 9,
	R1 = 11,
	/* the middle ps3 button */
	Ps3 = 16
	};

	int toNative(int button){
	switch (button){
	case 0: return Square;
	case 1: return Cross;
	case 2: return Circle;
	case 3: return Triangle;
	case 4: return Start;
	}

	return button;
	}

	int fromNative(int button){
	switch (button){
	case Square: return 0;
	case Cross: return 1;
	case Circle: return 2;
	case Triangle: return 3;
	case Start: return Start;
	default: return 5;
	}

	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Square: return Joystick::Button1;
	case Cross: return Joystick::Button2;
	case Circle: return Joystick::Button3;
	case Triangle: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	case Up: return Joystick::Up;
	case Down: return Joystick::Down;
	case Left: return Joystick::Left;
	case Right: return Joystick::Right;
	default: return Joystick::Invalid;
	}
	}

	/* TODO */
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	class LogitechPrecision: public ButtonMapping {
	public:
	enum Buttons{
	Button1 = 0,
	Button2 = 1,
	Button3 = 2,
	Button4 = 3,
	Start = 8,
	Select = 9,
	R2 = 7,
	R1 = 5,
	L2 = 6,
	L1 = 4
	};

	int toNative(int button){
	return -1;
	}

	int fromNative(int button){
	return -1;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Button1: return Joystick::Button1;
	case Button2: return Joystick::Button2;
	case Button3: return Joystick::Button3;
	case Button4: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	/* axis 1. negative up, positive down
	* axis 0, negative left, positive right
	*/
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	int tolerance = 10;
	if (axis == 0){
	if (motion < -tolerance){
	events.push_back(Joystick::Event(Joystick::Left, true));
	} else if (motion > tolerance){
	events.push_back(Joystick::Event(Joystick::Right, true));
	} else {
	/* fake a release for left and right */
	events.push_back(Joystick::Event(Joystick::Left, false));
	events.push_back(Joystick::Event(Joystick::Right, false));
	}
	} else if (axis == 1){
	if (motion < -tolerance){
	events.push_back(Joystick::Event(Joystick::Up, true));
	} else if (motion > tolerance){
	events.push_back(Joystick::Event(Joystick::Down, true));
	} else {
	events.push_back(Joystick::Event(Joystick::Up, false));
	events.push_back(Joystick::Event(Joystick::Down, false));
	}
	}
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	/* used for the ps3 controller with psl1ght's SDL version */
	class Ps3Controller: public ButtonMapping {
	public:
	enum Buttons{
	Left = 0,
	Down = 1,
	Right = 2,
	Up = 3,
	Select = 7,
	Start = 4,
	Square = 8,
	Cross = 9,
	Circle = 10,
	Triangle = 11,
	L1 = 13,
	R1 = 12,
	L2 = 15,
	R2 = 14,
	L3 = 6,
	R3 = 5
	};

	int toNative(int button){
	switch (button){
	case 0: return Square;
	case 1: return Cross;
	case 2: return Circle;
	case 3: return Triangle;
	case 4: return Start;
	}
	return button;
	}

	int fromNative(int button){
	switch (button){
	case Square: return 0;
	case Cross: return 1;
	case Circle: return 2;
	case Triangle: return 3;
	case Start: return Start;
	default: return 5;
	}
	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Square: return Joystick::Button1;
	case Cross: return Joystick::Button2;
	case Circle: return Joystick::Button3;
	case Triangle: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	case Up: return Joystick::Up;
	case Down: return Joystick::Down;
	case Left: return Joystick::Left;
	case Right: return Joystick::Right;
	default: return Joystick::Invalid;
	}
	}

	/* TODO */
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	class XBox360Controller: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	X = 2,
	Y = 3,
	L1 = 4,
	R1 = 5,
	Start = 6,
	Xbox = 7,
	L3 = 8,
	R3 = 9,
	select = 10
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case X: return Joystick::Button3;
	case Y: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	/* axis 6 and 7 are the hats. sdl passes them as hat events */
	#if 0
	if (axis == 6){
	if (motion < 0){
	events.push_back(Joystick::Event(Joystick::Left, true));
	} else if (motion > 0){
	events.push_back(Joystick::Event(Joystick::Right, true));
	} else if (motion == 0){
	/* fake a release for left and right */
	events.push_back(Joystick::Event(Joystick::Left, false));
	events.push_back(Joystick::Event(Joystick::Right, false));
	}
	} else if (axis == 7){
	if (motion < 0){
	events.push_back(Joystick::Event(Joystick::Up, true));
	} else if (motion > 0){
	events.push_back(Joystick::Event(Joystick::Down, true));
	} else if (motion == 0){
	events.push_back(Joystick::Event(Joystick::Up, false));
	events.push_back(Joystick::Event(Joystick::Down, false));
	}
	}
	#endif
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}
	};

	class Wiimote: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	Button1 = 2,
	Button2 = 3,
	Minus = 4,
	Plus = 5,
	Home = 6
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case Button1: return Joystick::Button3;
	case Button2: return Joystick::Button4;
	case Minus: return Joystick::Button5;
	case Plus: return Joystick::Button6;
	case Home: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	/* rotate all the directions 90 degrees */
	bool up = false; // right
	bool down = false; // left
	bool left = false; // up
	bool right = false; // down
	switch (motion){
	case SDL_HAT_CENTERED: break;
	- case SDL_HAT_UP: right = true; break;
	- case SDL_HAT_RIGHT: down = true; break;
	- case SDL_HAT_DOWN: left = true; break;
	- case SDL_HAT_LEFT: up = true; break;
	- case SDL_HAT_RIGHTUP: down = true; right = true; break;
	- case SDL_HAT_RIGHTDOWN: down = true; left = true; break;
	- case SDL_HAT_LEFTUP: up = true; right = true; break;
	- case SDL_HAT_LEFTDOWN: up = true; left = true; break;
	+ case SDL_HAT_UP: up = true; break;
	+ case SDL_HAT_RIGHT: right = true; break;
	+ case SDL_HAT_DOWN: down = true; break;
	+ case SDL_HAT_LEFT: left = true; break;
	+ case SDL_HAT_RIGHTUP: up = true; right = true; break;
	+ case SDL_HAT_RIGHTDOWN: down = true; right = true; break;
	+ case SDL_HAT_LEFTUP: up = true; left = true; break;
	+ case SDL_HAT_LEFTDOWN: down = true; left = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}
	};

	class GamecubePad: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	X = 2,
	Y = 3,
	Z = 4,
	Start = 7
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case X: return Joystick::Button3;
	case Y: return Joystick::Button4;
	case Z: return Joystick::Button5;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	// printf("axis %d motion %d\n", axis, motion);
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}

	};

	ButtonMapping * makeButtonMapping(string name){
	#ifdef PS3
	return new Ps3Controller();
	#endif
	if (name == "Sony PLAYSTATION(R)3 Controller"){
	return new Playstation3Controller();
	}
	if (name.find("Logitech(R) Precision(TM) Gamepad") != string::npos){
	return new LogitechPrecision();
	}
	if (name == "Microsoft X-Box 360 pad"){
	return new XBox360Controller();
	}
	if (name.find("Wiimote") != string::npos){
	return new Wiimote();
	}
	if (name.find("Gamecube") != string::npos){
	return new GamecubePad();
	}
	return new DefaultButtonMapping();
	}

	void SDLJoystick::poll(){
	events.clear();
	}

	static bool read_button(SDL_Joystick * joystick, int button){
	return SDL_JoystickGetButton(joystick, button);
	}

	JoystickInput SDLJoystick::readAll(){
	JoystickInput input;
	return input;
	if (joystick){
	int buttons = SDL_JoystickNumButtons(joystick);
	switch (buttons > 5 ? 5 : buttons){
	case 5: input.quit = read_button(joystick, buttonMapping->toNative(4));
	case 4: input.button4 = read_button(joystick, buttonMapping->toNative(3));
	case 3: input.button3 = read_button(joystick, buttonMapping->toNative(2));
	case 2: input.button2 = read_button(joystick, buttonMapping->toNative(1));
	case 1: input.button1 = read_button(joystick, buttonMapping->toNative(0));
	case 0: {
	break;
	}
	}
	}

	int axis = SDL_JoystickNumAxes(joystick);
	if (axis > 0){
	int position = SDL_JoystickGetAxis(joystick, 0);
	if (position < 0){
	input.left = true;
	} else if (position > 0){
	input.right = true;
	}
	}

	if (axis > 1){
	int position = SDL_JoystickGetAxis(joystick, 1);
	if (position < 0){
	input.up = true;
	} else if (position > 0){
	input.down = true;
	}
	}

	int hats = SDL_JoystickNumHats(joystick);
	if (hats > 0){
	int hat = SDL_JoystickGetHat(joystick, 0);
	if ((hat & SDL_HAT_UP) == SDL_HAT_UP){
	input.up = true;
	}
	if ((hat & SDL_HAT_DOWN) == SDL_HAT_DOWN){
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFT) == SDL_HAT_LEFT){
	input.left = true;
	}
	if ((hat & SDL_HAT_RIGHT) == SDL_HAT_RIGHT){
	input.right = true;
	}
	if ((hat & SDL_HAT_RIGHTUP) == SDL_HAT_RIGHTUP){
	input.right = true;
	input.up = true;
	}
	if ((hat & SDL_HAT_RIGHTDOWN) == SDL_HAT_RIGHTDOWN){
	input.right = true;
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFTDOWN) == SDL_HAT_LEFTDOWN){
	input.left = true;
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFTUP) == SDL_HAT_LEFTUP){
	input.left = true;
	input.up = true;
	}
	}

	return input;
	}

	SDLJoystick::~SDLJoystick(){
	if (joystick){
	SDL_JoystickClose(joystick);
	}
	}

	SDLJoystick::SDLJoystick():
	joystick(NULL){
	/* TODO: don't always open joystick 0, try to support all of them */
	if (SDL_NumJoysticks() > 0){
	Global::debug(1) << "Opened joystick '" << SDL_JoystickName(0) << "'" << std::endl;
	joystick = SDL_JoystickOpen(0);
	// printf("Opened joystick '%s'\n", SDL_JoystickName(4));
	buttonMapping = makeButtonMapping(SDL_JoystickName(0));
	}
	}

	void SDLJoystick::pressButton(int button){
	// Global::debug(0) << "Pressed button " << button << std::endl;
	if (joystick){
	Key event = buttonMapping->toKey(button);
	if (event != Invalid){
	events.push_back(Event(event, true));
	}
	}
	}

	void SDLJoystick::releaseButton(int button){
	if (joystick){
	Key event = buttonMapping->toKey(button);
	if (event != Invalid){
	events.push_back(Event(event, false));
	}
	}
	}

	void SDLJoystick::hatMotion(int motion){
	if (joystick){
	buttonMapping->hatMotionEvents(motion, events);
	}
	}

	void SDLJoystick::axisMotion(int axis, int motion){
	// Global::debug(0) << "Axis motion on " << axis << " motion " << motion << std::endl;
	if (joystick){
	buttonMapping->axisMotionEvents(axis, motion, events);
	/*
	Event move = buttonMapping->axisMotionToEvent(axis, motion);
	if (move.key != Invalid){
	events.push_back(move);
	}
	*/
	}
	}

	int SDLJoystick::getDeviceId() const {
	if (joystick){
	return SDL_JoystickIndex(joystick);
	}

	return -1;
	}

	#endif
	diff --git a/util/nacl/network-system.cpp b/util/nacl/network-system.cpp
	index 9c9501b9..0a6d2df5 100644
	--- a/util/nacl/network-system.cpp
	+++ b/util/nacl/network-system.cpp
	@@ -1,812 +1,804 @@
	#ifdef NACL

	/* documentation for ppapi
	* http://code.google.com/chrome/nativeclient/docs/reference/peppercpp/inherits.html
	*/

	/* issues with getting data
	* 1. the function that starts the game is called from the main chrome thread
	* which starts from a javascript call to module.PostMessage('run').
	* ...
	*
	*/

	#include <unistd.h>
	#include <errno.h>
	#include "network-system.h"
	#include <sstream>
	#include <fstream>
	#include "../funcs.h"
	#include "../debug.h"
	#include <ppapi/c/pp_errors.h>
	#include <ppapi/cpp/url_loader.h>
	#include <ppapi/cpp/url_request_info.h>
	#include <ppapi/cpp/url_response_info.h>
	#include <ppapi/c/ppb_url_request_info.h>
	#include <ppapi/cpp/completion_callback.h>

	using std::string;
	using std::map;
	using std::vector;
	using std::ostringstream;
	using std::ifstream;

	namespace Nacl{

	static const char * CONTEXT = "nacl";

	typedef Path::AbsolutePath AbsolutePath;
	typedef Path::RelativePath RelativePath;

	enum RequestType{
	Exists
	};

	struct Request{
	RequestType type;
	AbsolutePath absolute;
	RelativePath relative;
	bool complete;
	bool success;
	};

	Request operation;

	struct NaclRequest{
	virtual ~NaclRequest(){
	}

	virtual void start() = 0;
	};

	struct NaclRequestOpen: public NaclRequest {
	NaclRequestOpen(pp::Instance * instance, const string & url, Manager * manager):
	request(instance),
	loader(instance),
	url(url),
	manager(manager){
	request.SetURL(url);
	request.SetMethod("GET");
	// request.SetProperty(PP_URLREQUESTPROPERTY_RECORDDOWNLOADPROGRESS, pp::Var((bool) PP_TRUE));
	}

	void start(){
	Global::debug(2) << "Request open for url " << url << std::endl;
	pp::CompletionCallback callback(&NaclRequestOpen::onFinish, this);
	int32_t ok = loader.Open(request, callback);
	Global::debug(2) << "Open " << ok << std::endl;
	if (ok != PP_OK_COMPLETIONPENDING){
	// Global::debug(0) << "Call on main thread" << std::endl;
	// core->CallOnMainThread(0, callback, ok);
	callback.Run(ok);
	}
	// Global::debug(1) << "Callback running" << std::endl;
	}

	static void onFinish(void * me, int32_t result){
	NaclRequestOpen * self = (NaclRequestOpen*) me;
	self->finish(result);
	}

	void finish(int32_t result);

	pp::URLRequestInfo request;
	pp::URLLoader loader;
	string url;
	Manager * manager;
	};

	struct NaclRequestExists: public NaclRequest {
	NaclRequestExists(pp::Instance * instance, const string & url, Manager * manager):
	request(instance),
	loader(instance),
	url(url),
	manager(manager){
	request.SetURL(url);
	request.SetMethod("GET");
	}

	void start(){
	pp::CompletionCallback callback(&NaclRequestExists::onFinish, this);
	int32_t ok = loader.Open(request, callback);
	if (ok != PP_OK_COMPLETIONPENDING){
	callback.Run(ok);
	}
	}

	static void onFinish(void * me, int32_t result){
	NaclRequestExists * self = (NaclRequestExists*) me;
	self->finish(result);
	}

	void finish(int32_t result);

	pp::URLRequestInfo request;
	pp::URLLoader loader;
	string url;
	Manager * manager;
	};

	class FileHandle{
	public:
	FileHandle():
	buffer(NULL){
	}

	~FileHandle(){
	delete[] buffer;
	}

	class Reader{
	public:
	static const int PAGE_SIZE = 1024 * 32;
	struct Page{
	Page():
	buffer(NULL),
	size(0),
	next(NULL){
	buffer = new char[PAGE_SIZE];
	}

	char * buffer;
	int size;
	Page * next;

	~Page(){
	delete[] buffer;
	delete next;
	}
	};

	Reader(pp::CompletionCallback finish, pp::URLLoader & loader, FileHandle * handle, pp::Core * core):
	finish(finish),
	loader(loader),
	handle(handle),
	core(core),
	tries(0){
	current = &page;
	}

	int getSize(){
	Page * use = &page;
	int total = 0;
	while (use != NULL){
	total += use->size;
	use = use->next;
	}
	return total;
	}

	void copy(char * buffer){
	Page * use = &page;
	while (use != NULL){
	memcpy(buffer, use->buffer, use->size);
	buffer += use->size;
	use = use->next;
	}
	}

	void read(){
	pp::CompletionCallback callback(&Reader::onRead, this);
	if (current->size == PAGE_SIZE){
	Page * next = new Page();
	current->next = next;
	current = next;
	}
	int32_t ok = loader.ReadResponseBody(current->buffer + current->size, PAGE_SIZE - current->size, callback);
	if (ok != PP_OK_COMPLETIONPENDING){
	callback.Run(ok);
	}
	}

	static void onRead(void * self, int32_t result){
	Reader * reader = (Reader*) self;
	reader->didRead(result);
	}

	void didRead(int32_t result){
	Global::debug(2) << "Read " << result << " bytes" << std::endl;
	current->size += result;
	if (result > 0){
	tries = 0;
	read();
	} else {
	if (tries >= 3){
	handle->readDone(this);
	} else {
	tries += 1;
	pp::CompletionCallback callback(&Reader::doRead, this);
	core->CallOnMainThread((tries - 1) * 25, callback, 0);
	}
	}
	}

	static void doRead(void * self, int32_t result){
	Reader * reader = (Reader*) self;
	reader->read();
	}

	pp::CompletionCallback finish;
	pp::URLLoader & loader;
	Page page;
	Page * current;
	FileHandle * handle;
	pp::Core * core;
	int tries;
	};

	void readAll(pp::CompletionCallback finish, pp::Core * core, pp::URLLoader & loader){
	reader = new Reader(finish, loader, this, core);
	reader->read();
	}

	void readDone(Reader * reader){
	length = reader->getSize();
	Global::debug(2) << "Done reading, got " << length << " bytes" << std::endl;
	position = 0;
	buffer = new char[length];
	reader->copy(buffer);
	reader->finish.Run(0);
	}

	int read(void * buffer, size_t count){
	size_t bytes = position + count < length ? count : (length - position);
	memcpy(buffer, this->buffer + position, bytes);
	position += bytes;
	return bytes;
	}

	off_t seek(off_t offset, int whence){
	switch (whence){
	case SEEK_SET: {
	position = offset;
	break;
	}
	case SEEK_CUR: {
	position += offset;
	break;
	}
	case SEEK_END: {
	position = length - offset;
	break;
	}
	}

	return position;
	}

	off_t position;
	off_t length;
	char * buffer;
	Util::ReferenceCount<Reader> reader;
	};

	class Manager{
	public:
	Manager(pp::Instance * instance, pp::Core * core):
	instance(instance),
	core(core),
	factory(this){
	- next = 2;
	}

	pp::Instance * instance;
	pp::Core * core;
	Util::ReferenceCount<NaclRequest> request;
	pp::CompletionCallbackFactory<Manager> factory;

	- int next;
	-
	struct OpenFileData{
	const char * path;
	Util::ReferenceCount<FileHandle> file;
	};

	struct ExistsData{
	const char * path;
	bool exists;
	};

	- struct CloseFileData{
	- int fd;
	- };
	-
	OpenFileData openFileData;
	- CloseFileData closeFileData;
	ExistsData existsData;

	Util::Thread::LockObject lock;
	volatile bool done;

	Util::ReferenceCount<FileHandle> openFile(const char * path){
	Global::debug(1, CONTEXT) << "open " << path << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	done = false;
	openFileData.path = path;
	pp::CompletionCallback callback(&Manager::doOpenFile, this);
	core->CallOnMainThread(0, callback, 0);
	lock.wait(done);
	return openFileData.file;
	}

	bool exists(const string & path){
	Global::debug(1, CONTEXT) << "exists " << path << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	done = false;
	existsData.exists = false;
	existsData.path = path.c_str();
	pp::CompletionCallback callback(&Manager::doExists, this);
	core->CallOnMainThread(0, callback, 0);
	lock.wait(done);
	return existsData.exists;
	}

	static void doExists(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->continueExists();
	}

	void continueExists(){
	request = new NaclRequestExists(instance, existsData.path, this);
	request->start();
	}

	void success(NaclRequestExists & exists){
	existsData.exists = true;
	requestComplete();
	}

	void failure(NaclRequestExists & exists){
	existsData.exists = false;
	requestComplete();
	}

	/* called by the main thread */
	static void doOpenFile(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->continueOpenFile();
	}

	void continueOpenFile(){
	request = new NaclRequestOpen(instance, openFileData.path, this);
	request->start();
	}

	void requestComplete(){
	/* destroy request on the main thread */
	request = NULL;
	lock.lockAndSignal(done, true);
	}

	void success(NaclRequestOpen & open){
	pp::URLResponseInfo info = open.loader.GetResponseInfo();
	if (info.GetStatusCode() == 200){
	Global::debug(1) << "Opened file" << std::endl;
	/*
	int64_t received = 0;
	int64_t total = 0;
	if (open.loader.GetDownloadProgress(&received, &total)){
	Global::debug(0) << "Downloaded " << received << " total " << total << std::endl;
	}
	*/
	Util::ReferenceCount<FileHandle> handle = new FileHandle();
	pp::CompletionCallback callback(&Manager::completeRead, this);
	openFileData.file = handle;
	handle->readAll(callback, core, open.loader);
	/*
	openFileData.file = nextFileDescriptor();
	fileTable[openFileData.file] = new FileHandle(request.convert<NaclRequestOpen>());
	readEntireFile(fileTable[openFileData.file]);
	*/
	} else {
	Global::debug(1) << "Could not open file" << std::endl;
	requestComplete();
	}
	}

	static void completeRead(void * self, int32_t result){
	Manager * manager = (Manager*) self;
	manager->requestComplete();
	}

	void failure(NaclRequestOpen & open){
	requestComplete();
	}
	};

	void NaclRequestOpen::finish(int32_t result){
	if (result == 0){
	manager->success(*this);
	} else {
	manager->failure(*this);
	}
	}

	void NaclRequestExists::finish(int32_t result){
	if (result == 0){
	pp::URLResponseInfo info = loader.GetResponseInfo();
	if (info.GetStatusCode() == 200){
	manager->success(*this);
	} else {
	manager->failure(*this);
	}
	} else {
	manager->failure(*this);
	}
	}

	NetworkSystem::NetworkSystem(pp::Instance * instance, pp::Core * core):
	instance(instance),
	core(core){
	}

	NetworkSystem::~NetworkSystem(){
	}

	AbsolutePath NetworkSystem::find(const RelativePath & path){
	AbsolutePath all = Util::getDataPath2().join(path);
	if (exists(all)){
	return all;
	}
	throw Storage::NotFound(__FILE__, __LINE__, path.path());
	}

	RelativePath NetworkSystem::cleanse(const AbsolutePath & path){
	string str = path.path();
	if (str.find(Util::getDataPath2().path()) == 0){
	str.erase(0, Util::getDataPath2().path().length());
	} else if (str.find(userDirectory().path()) == 0){
	str.erase(0, userDirectory().path().length());
	}
	return RelativePath(str);
	}

	bool NetworkSystem::exists(const RelativePath & path){
	try{
	AbsolutePath absolute = find(path);
	return true;
	} catch (const Storage::NotFound & found){
	return false;
	}
	}

	bool NetworkSystem::exists(const AbsolutePath & path){
	Util::Thread::ScopedLock scoped(lock);
	if (existsCache.find(path) != existsCache.end()){
	return existsCache[path];
	}
	Manager manager(instance, core);
	bool what = manager.exists(path.path());
	existsCache[path] = what;
	return what;
	}

	string NetworkSystem::readFileAsString(const AbsolutePath & path){
	if (!exists(path)){
	ostringstream fail;
	fail << "Could not read " << path.path();
	throw Filesystem::NotFound(__FILE__, __LINE__, fail.str());
	}
	ostringstream buffer;
	ifstream input(path.path().c_str());
	char stuff[1024];
	while (input.good()){
	input.read(stuff, sizeof(stuff) - 1);
	stuff[sizeof(stuff) - 1] = '\0';
	buffer << stuff;
	}
	return buffer.str();
	}

	static vector<string> split(string input, char splitter){
	vector<string> all;
	size_t found = input.find(splitter);
	while (found != string::npos){
	all.push_back(input.substr(0, found));
	input.erase(0, found + 1);
	found = input.find(splitter);
	}
	if (input.size() != 0){
	all.push_back(input);
	}
	return all;
	}

	vector<AbsolutePath> NetworkSystem::readDirectory(const AbsolutePath & dataPath){
	/* assume existence of 'directory.txt' in the given directory */
	AbsolutePath fullPath = dataPath.join(RelativePath("directory.txt"));
	string all = readFileAsString(fullPath);
	vector<string> files = split(all, '\n');
	vector<AbsolutePath> paths;
	for (vector<string>::iterator it = files.begin(); it != files.end(); it++){
	string what = *it;
	paths.push_back(dataPath.join(RelativePath(what)));
	}
	return paths;
	}

	/* check if 'foo/bar/baz.txt' matches .txt /
	static bool matchFile(const AbsolutePath & path, const string & find, bool insensitive = false){
	string file = path.getFilename().path();
	unsigned int index = 0;
	while (index < file.size()){
	if (index >= find.size()){
	return false;
	}
	if (find[index] == '*'){
	return true;
	}
	if (insensitive){
	if (tolower(find[index]) != tolower(file[index])){
	return false;
	}
	} else {
	if (find[index] != file[index]){
	return false;
	}
	}
	index += 1;
	}
	return true;
	}

	std::vector<AbsolutePath> NetworkSystem::getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive){
	vector<AbsolutePath> files = readDirectory(dataPath);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, find)){
	paths.push_back(check);
	}
	}
	return paths;
	}

	std::vector<AbsolutePath> NetworkSystem::getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive){
	vector<AbsolutePath> files = readDirectory(dataPath);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, find)){
	paths.push_back(check);
	}

	vector<AbsolutePath> more = getFilesRecursive(check, find, caseInsensitive);
	paths.insert(paths.end(), more.begin(), more.end());
	}
	return paths;
	}

	AbsolutePath NetworkSystem::configFile(){
	return AbsolutePath("paintownrc");
	}

	AbsolutePath NetworkSystem::userDirectory(){
	return AbsolutePath("paintown-user");
	}

	std::vector<AbsolutePath> NetworkSystem::findDirectories(const RelativePath & path){
	vector<AbsolutePath> files = readDirectory(find(path));
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	try{
	/* if we can read directory contents then its a directory */
	vector<AbsolutePath> more = readDirectory(check);
	paths.push_back(check);
	} catch (const Filesystem::NotFound & fail){
	}
	}
	return paths;

	}

	AbsolutePath NetworkSystem::findInsensitive(const RelativePath & path){
	try{
	/* try sensitive lookup first */
	return find(path);
	} catch (const Filesystem::NotFound & fail){
	}
	/* get the base directory */
	AbsolutePath directory = find(path.getDirectory());
	return lookupInsensitive(directory, path.getFilename());

	}

	AbsolutePath NetworkSystem::lookupInsensitive(const AbsolutePath & directory, const RelativePath & path){
	vector<AbsolutePath> files = readDirectory(directory);
	vector<AbsolutePath> paths;
	for (vector<AbsolutePath>::iterator it = files.begin(); it != files.end(); it++){
	AbsolutePath check = *it;
	if (matchFile(check, path.path(), true)){
	return check;
	}
	}
	ostringstream out;
	out << "Cannot find " << path.path() << " in " << directory.path();
	throw Filesystem::NotFound(__FILE__, __LINE__, out.str());
	}

	int nextFileDescriptor(){
	static int next = 3;
	int n = next;
	next += 1;
	return n;
	}

	int NetworkSystem::libcOpen(const char * path, int mode, int params){
	Manager manager(instance, core);
	Util::ReferenceCount<FileHandle> handle = manager.openFile(path);
	Util::Thread::ScopedLock scoped(lock);
	int file = nextFileDescriptor();
	fileTable[file] = handle;
	return file;
	}

	ssize_t NetworkSystem::libcRead(int fd, void * buffer, size_t count){
	Util::Thread::ScopedLock scoped(lock);
	if (fileTable.find(fd) == fileTable.end()){
	return EBADF;
	}

	Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	return handle->read(buffer, count);
	}

	int NetworkSystem::libcClose(int fd){
	Util::Thread::ScopedLock scoped(lock);
	if (fileTable.find(fd) == fileTable.end()){
	return -1;
	/* set errno to EBADF */
	}

	fileTable.erase(fileTable.find(fd));
	return 0;
	}

	off_t NetworkSystem::libcLseek(int fd, off_t offset, int whence){
	Global::debug(2, CONTEXT) << "seek fd " << fd << " offset " << offset << " whence " << whence << std::endl;
	Util::Thread::ScopedLock scoped(lock);
	if (fileTable.find(fd) == fileTable.end()){
	return -1;
	}

	Util::ReferenceCount<FileHandle> handle = fileTable[fd];
	return handle->seek(offset, whence);
	}

	}

	/* NOTE FIXME Missing I/O in Native Client */

	Nacl::NetworkSystem & getSystem(){
	return (Nacl::NetworkSystem&) Storage::instance();
	}

	extern "C" {

	/* http://sourceware.org/binutils/docs-2.21/ld/Options.html#index-g_t_002d_002dwrap_003d_0040var_007bsymbol_007d-261
	* --wrap=symbol
	* Use a wrapper function for symbol. Any undefined reference to symbol will be resolved to __wrap_symbol. Any undefined reference to __real_symbol will be resolved to symbol.
	*/
	int __wrap_open(const char * path, int mode, int params){
	return getSystem().libcOpen(path, mode, params);
	}

	ssize_t __wrap_read(int fd, void * buf, size_t count){
	return getSystem().libcRead(fd, buf, count);
	}

	extern int __real_close(int fd);

	int __wrap_close(int fd){
	/* we may be given a file descriptor that we do not own, probably
	* because some file descriptors are really tied to sockets so
	* if we don't own the fd then pass it to the real close function.
	*/
	int ok = getSystem().libcClose(fd);
	if (ok == -1){
	return __real_close(fd);
	}
	return ok;
	}

	off_t __wrap_lseek(int fd, off_t offset, int whence){
	return getSystem().libcLseek(fd, offset, whence);
	}

	int pipe (int filedes[2]){
	return -1;
	}

	int mkdir (const char *filename, mode_t mode){
	return -1;
	}

	int access(const char *filename, int how){
	return -1;
	}

	char * getcwd (char *buffer, size_t size){
	return NULL;
	}

	int lstat (const char path, struct stat buf){
	return -1;
	}

	int rmdir (const char *filename){
	return -1;
	}

	int chdir (const char *filename){
	return -1;
	}

	int setuid (uid_t newuid){
	return 0;
	}

	int seteuid (uid_t uid){
	return 0;
	}

	uid_t geteuid (void){
	return NULL;
	}

	int setgid (gid_t gid){
	return 0;
	}

	gid_t getgid (void){
	return NULL;
	}

	int setegid (gid_t gid){
	return 0;
	}

	gid_t getegid (void){
	return NULL;
	}

	char * getlogin (void){
	return NULL;
	}

	uid_t getuid(void){
	return NULL;
	}

	struct passwd * getpwuid (uid_t uid){
	return NULL;
	}

	struct passwd * getpwnam (const char *name){
	return NULL;
	}

	struct group * getgrnam(const char *name){
	return NULL;
	}

	struct group * getgrgid(gid_t gid){
	return NULL;
	}

	int link (const char oldname, const char newname){
	return -1;
	}

	int unlink (const char *filename){
	return -1;
	}

	int kill(pid_t pid, int sig){
	return -1;
	}

	}

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 10:18 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68351
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions