/*PS3 MANAGER API

* Copyright (c) 2014 _NzV_.

*

* This code is write by _NzV_ <donm7v@gmail.com>.

* It may be used for any purpose as long as this notice remains intact on all

* source code distributions.

*/

using System;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Text.RegularExpressions;

using System.Windows.Forms;

namespace PS3ManagerAPI

{

public class PS3MAPI

{

public int PS3M_API_PC_LIB_VERSION = 0x0112;

public CORE_CMD Core = new CORE_CMD();

public SERVER_CMD Server = new SERVER_CMD();

public PS3_CMD PS3 = new PS3_CMD();

public PROCESS_CMD Process = new PROCESS_CMD();

public PS3MAPI()

{

Core = new CORE_CMD();

Server = new SERVER_CMD();

PS3 = new PS3_CMD();

Process = new PROCESS_CMD();

}

#region PS3MAPI_CLient

/// <summary>Get PS3 Manager PC Lib Version.</summary>

public string GetLibVersion_Str()

{

string ver = PS3M_API_PC_LIB_VERSION.ToString("X4");

string char1 = ver.Substring(1, 1) + ".";

string char2 = ver.Substring(2, 1) + ".";

string char3 = ver.Substring(3, 1);

return char1 + char2 + char3;

}

/// <summary>

/// Indicates if PS3MAPI is connected

/// </summary>

public bool IsConnected

{

get { return PS3MAPI_Client_Server.IsConnected; }

}

/// <summary>

/// Indicates if PS3MAPI is attached

/// </summary>

public bool IsAttached

{

get { return PS3MAPI_Client_Server.IsAttached; }

}

/// <summary>Connect the target with "ConnectDialog".</summary>

/// <param name="ip">Ip</param>

/// <param name="port">Port</param>

public bool ConnectTarget(string ip, int port = 7887)

{

try

{

PS3MAPI_Client_Server.Connect(ip, port);

return true;

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Connect the target with "ConnectDialog".</summary>

public bool ConnectTarget()

{

ConnectDialog input = new ConnectDialog();

try

{

bool result = false;

if (input.ShowDialog() == System.Windows.Forms.DialogResult.OK)

{

result = ConnectTarget(input.txtIp.Text, int.Parse(input.txtPort.Text));

}

if (input != null)

{

input.Dispose();

input = null;

}

return result;

}

catch (Exception ex)

{

if (input != null)

{

input.Dispose();

input = null;

}

throw new Exception(ex.Message, ex);

}

}

/// <summary>Attach to process by pid.</summary>

/// <param name="pid">Process PID</param>

public bool AttachProcess(uint pid)

{

try

{

Process.Process_Pid = pid;

return true;

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Attach to process with "AttachDialog".</summary>

public bool AttachProcess()

{

AttachDialog input = null;

try

{

retry:

bool result = false;

if (input != null)

{

input.Dispose();

input = null;

}

input = new AttachDialog(this);

System.Windows.Forms.DialogResult dialog_result = input.ShowDialog();

if (dialog_result == System.Windows.Forms.DialogResult.OK)

{

string[] split = input.comboBox1.Text.Split(new char[] { '_' });

result = AttachProcess(System.Convert.ToUInt32(split[0], 16));

}

else if (dialog_result == System.Windows.Forms.DialogResult.Retry)

{

goto retry;

}

if (input != null)

{

input.Dispose();

}

return result;

}

catch (Exception ex)

{

if (input != null)

{

input.Dispose();

input = null;

}

throw new Exception(ex.Message, ex);

}

}

/// <summary>Disconnect the target.</summary>

public void DisconnectTarget()

{

try

{

PS3MAPI_Client_Server.Disconnect();

}

catch// (Exception ex)

{

// throw new Exception(ex.Message, ex);

}

}

LogDialog LogDialog = null;

/// <summary>Show log with "LogDialog".</summary>

public void ShowLog()

{

if (LogDialog == null) LogDialog = new LogDialog(this);

LogDialog.Show();

}

/// <summary>Show log with "LogDialog".</summary>

public string Log

{

get { return PS3MAPI_Client_Server.Log; }

}

public class SERVER_CMD

{

/// <summary>

/// Specified Timeout: Defaults to 5000 (5 seconds)

/// </summary>

public int Timeout

{

get { return PS3MAPI_Client_Server.Timeout; }

set { PS3MAPI_Client_Server.Timeout = value; }

}

/// <summary>Get PS3 Manager API Server Version.</summary>

public uint GetVersion()

{

try

{

return PS3MAPI_Client_Server.Server_Get_Version();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get PS3 Manager API Server Version.</summary>

public string GetVersion_Str()

{

string ver = PS3MAPI_Client_Server.Server_Get_Version().ToString("X4");

string char1 = ver.Substring(1, 1) + ".";

string char2 = ver.Substring(2, 1) + ".";

string char3 = ver.Substring(3, 1);

return char1 + char2 + char3;

}

}

public class CORE_CMD

{

/// <summary>Get PS3 Manager API Core Version.</summary>

public uint GetVersion()

{

try

{

return PS3MAPI_Client_Server.Core_Get_Version();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get PS3 Manager API Core Version.</summary>

public string GetVersion_Str()

{

string ver = PS3MAPI_Client_Server.Core_Get_Version().ToString("X4");

string char1 = ver.Substring(1, 1) + ".";

string char2 = ver.Substring(2, 1) + ".";

string char3 = ver.Substring(3, 1);

return char1 + char2 + char3;

}

}

public class PS3_CMD

{

/// <summary>Get PS3 Firmware Version.</summary>

public uint GetFirmwareVersion()

{

try

{

return PS3MAPI_Client_Server.PS3_GetFwVersion();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get PS3 Firmware Version.</summary>

public string GetFirmwareVersion_Str()

{

string ver = PS3MAPI_Client_Server.PS3_GetFwVersion().ToString("X4");

string char1 = ver.Substring(1, 1) + ".";

string char2 = ver.Substring(2, 1);

string char3 = ver.Substring(3, 1);

return char1 + char2 + char3;

}

/// <summary>Get PS3 Firmware Type.</summary>

public string GetFirmwareType()

{

try

{

return PS3MAPI_Client_Server.PS3_GetFirmwareType();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public enum PowerFlags

{

ShutDown,

QuickReboot,

SoftReboot,

HardReboot

}

/// <summary>Shutdown Or Reboot PS3.</summary>

/// <param name="flag">Shutdown, QuickReboot, SoftReboot, HardReboot</param>

public void Power(PowerFlags flag)

{

try

{

if (flag == PowerFlags.ShutDown) PS3MAPI_Client_Server.PS3_Shutdown();

else if (flag == PowerFlags.QuickReboot) PS3MAPI_Client_Server.PS3_Reboot();

else if (flag == PowerFlags.SoftReboot) PS3MAPI_Client_Server.PS3_SoftReboot();

else if (flag == PowerFlags.HardReboot) PS3MAPI_Client_Server.PS3_HardReboot();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>PS3 VSH Notify.</summary>

/// <param name="msg)">Your message</param>

public void Notify(string msg)

{

try

{

PS3MAPI_Client_Server.PS3_Notify(msg);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public enum BuzzerMode

{

Single,

Double,

Triple

}

/// <summary>Ring PS3 Buzzer.</summary>

/// <param name="mode">Simple, Double, Continuous</param>

public void RingBuzzer(BuzzerMode mode)

{

try

{

if (mode == BuzzerMode.Single) PS3MAPI_Client_Server.PS3_Buzzer(1);

else if (mode == BuzzerMode.Double) PS3MAPI_Client_Server.PS3_Buzzer(2);

else if (mode == BuzzerMode.Triple) PS3MAPI_Client_Server.PS3_Buzzer(3);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public enum LedColor

{

Red = 0,

Green = 1,

Yellow = 2

}

public enum LedMode

{

Off = 0,

On = 1,

BlinkFast = 2,

BlinkSlow = 3

}

/// <summary>PS3 Led.</summary>

/// <param name="color">Red, Green, Yellow</param>

/// <param name="mode">Off, On, BlinkFast, BlinkSlow</param>

public void Led(LedColor color, LedMode mode)

{

try

{

PS3MAPI_Client_Server.PS3_Led(Convert.ToInt32(color), Convert.ToInt32(mode));

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get PS3 Temperature.</summary>

/// <param name="cpu">Return value for the cpu temperature in Celsius.</param>

/// <param name="rsx">Return value for the rsx temperature in Celsius.</param>

public void GetTemperature( out uint cpu, out uint rsx)

{

cpu = 0; rsx = 0;

try

{

PS3MAPI_Client_Server.PS3_GetTemp(out cpu, out rsx);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Disable PS3 Syscall.</summary>

/// <param name="num">Syscall number</param>

public void DisableSyscall(int num)

{

try

{

PS3MAPI_Client_Server.PS3_DisableSyscall(num);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Return true if this syscall is enbaled</summary>

/// <param name="num">Syscall number</param>

public bool CheckSyscall(int num)

{

try

{

return PS3MAPI_Client_Server.PS3_CheckSyscall(num);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public enum Syscall8Mode

{

Enabled = 0,

Only_CobraMambaAndPS3MAPI_Enabled = 1,

Only_PS3MAPI_Enabled = 2,

FakeDisabled = 3,

Disabled = 4

}

/// <summary>Partial Disable PS3 Syscall 8.</summary>

/// <param name="mode">Enabled, Only Cobra and PS3M_API features enabled, Only PS3M_API features enabled, Fake Disable</param>

public void PartialDisableSyscall8(Syscall8Mode mode)

{

try

{

if (mode == Syscall8Mode.Enabled) PS3MAPI_Client_Server.PS3_PartialDisableSyscall8(0);

else if (mode == Syscall8Mode.Only_CobraMambaAndPS3MAPI_Enabled) PS3MAPI_Client_Server.PS3_PartialDisableSyscall8(1);

else if (mode == Syscall8Mode.Only_PS3MAPI_Enabled) PS3MAPI_Client_Server.PS3_PartialDisableSyscall8(2);

else if (mode == Syscall8Mode.FakeDisabled) PS3MAPI_Client_Server.PS3_PartialDisableSyscall8(3);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Remove COBRA/MAMBA Hook.</summary>

public Syscall8Mode PartialCheckSyscall8()

{

try

{

if (PS3MAPI_Client_Server.PS3_PartialCheckSyscall8() == 0) return Syscall8Mode.Enabled;

else if (PS3MAPI_Client_Server.PS3_PartialCheckSyscall8() == 1) return Syscall8Mode.Only_CobraMambaAndPS3MAPI_Enabled;

else if (PS3MAPI_Client_Server.PS3_PartialCheckSyscall8() == 2) return Syscall8Mode.Only_PS3MAPI_Enabled;

else return Syscall8Mode.FakeDisabled;

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public void RemoveHook()

{

try

{

PS3MAPI_Client_Server.PS3_RemoveHook();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Clear PS3 History.</summary>

/// <param name="include_directory">If set to true, "unsafe" directory will be also deleted.</param>

public void ClearHistory(bool include_directory = true)

{

try

{

PS3MAPI_Client_Server.PS3_ClearHistory(include_directory);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Check Partial Syscall8 disable</summary>

}

public class PROCESS_CMD

{

public MEMORY_CMD Memory = new MEMORY_CMD();

public MODULES_CMD Modules = new MODULES_CMD();

public PROCESS_CMD()

{

Memory = new MEMORY_CMD();

Modules = new MODULES_CMD();

}

/// <summary>

/// Return all process_pid

/// </summary>

public uint[] Processes_Pid

{

get { return PS3MAPI_Client_Server.Processes_Pid; }

}

/// <summary>

/// Return current attached process_pid

/// </summary>)

public uint Process_Pid

{

get { return PS3MAPI_Client_Server.Process_Pid; }

set { PS3MAPI_Client_Server.Process_Pid = value; }

}

/// <summary>Get a pid list of all runing processes.</summary>

public uint[] GetPidProcesses()

{

try

{

return PS3MAPI_Client_Server.Process_GetPidList();

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get name of this process.</summary>

/// <param name="pid">Process Pid</param>

public string GetName(uint pid)

{

try

{

return PS3MAPI_Client_Server.Process_GetName(pid);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

public class MEMORY_CMD

{

/// <summary>Set memory to the attached process.</summary>

/// <param name="pid">Process Pid</param>

/// <param name="Address">Address</param>

/// <param name="Bytes">Bytes</param>

public void Set(uint Pid, uint Address, byte[] Bytes)

{

try

{

PS3MAPI_Client_Server.Memory_Set(Pid, Address, Bytes);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get memory from the attached process.</summary>

/// <param name="pid">Process Pid</param>

/// <param name="Address">Address</param>

/// <param name="Bytes">Bytes</param>

public void Get(uint Pid, uint Address, byte[] Bytes)

{

try

{

PS3MAPI_Client_Server.Memory_Get(Pid, Address, Bytes);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get memory from the attached process.</summary>

/// <param name="pid">Process Pid</param>

/// <param name="Address">Address</param>

/// <param name="Length">Length</param>

public byte[] Get(uint Pid, uint Address, uint Length)

{

try

{

byte[] buffer = new byte[Length];

PS3MAPI_Client_Server.Memory_Get(Pid, Address, buffer);

return buffer;

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

}

public class MODULES_CMD

{

/// <summary>

/// Return all modules_prx_id

/// </summary>

public int[] Modules_Prx_Id

{

get { return PS3MAPI_Client_Server.Modules_Prx_Id; }

}

/// <summary>Get a prx_id list of all modules for this process.</summary>

/// <param name="pid">Process Pid</param>

public int[] GetPrxIdModules(uint pid)

{

try

{

return PS3MAPI_Client_Server.Module_GetPrxIdList(pid);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get name of this module</summary>

/// <param name="pid">Process Pid</param>

/// <param name="prxid">Module Prx_id</param>

public string GetName(uint pid, int prxid)

{

try

{

return PS3MAPI_Client_Server.Module_GetName(pid, prxid);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Get filename of this module</summary>

/// <param name="pid">Process Pid</param>

/// <param name="prxid">Module Prx_id</param>

public string GetFilename(uint pid, int prxid)

{

try

{

return PS3MAPI_Client_Server.Module_GetFilename(pid, prxid);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Load a module.</summary>

/// <param name="pid">Process Pid</param>

/// <param name="path">Path of the plugin to load.</param>

public void Load(uint pid, string path)

{

try

{

PS3MAPI_Client_Server.Module_Load(pid, path);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

/// <summary>Unload a module.</summary>

/// <param name="pid">Process Pid</param>

/// <param name="prxid">Module Prx_id</param>

public void Unload(uint pid, int prxid)

{

try

{

PS3MAPI_Client_Server.Module_Unload(pid, prxid);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

}

}

}

#endregion PS3MAPI_CLient

#region PS3MAPI_Client_Web

internal class PS3MAPI_Client_Web

{

//Not Yet

}

#endregion PS3MAPI_Client_Web

#region PS3MAPI_Client_Server

internal class PS3MAPI_Client_Server

{

#region Private Members

static private int ps3m_api_server_minversion = 0x0111;

static private PS3MAPI_ResponseCode eResponseCode;

static private string sResponse;

static private string sMessages = "";

static private string sServerIP = "";

static private int iPort = 7887;

static private string sBucket = "";

static private int iTimeout = 5000; // 5 Second

static private uint iPid = 0;

static private uint[] iprocesses_pid = new uint[16];

static private int[] imodules_prx_id = new int[64];

static private string sLog = "";

#endregion Private Members

#region Internal Members

static internal Socket main_sock;

static internal Socket listening_sock;

static internal Socket data_sock;

static internal IPEndPoint main_ipEndPoint;

static internal IPEndPoint data_ipEndPoint;

internal enum PS3MAPI_ResponseCode

{

DataConnectionAlreadyOpen = 125,

MemoryStatusOK = 150,

CommandOK = 200,

RequestSuccessful = 226,

EnteringPassiveMode = 227,

PS3MAPIConnected = 220,

PS3MAPIConnectedOK = 230,

MemoryActionCompleted = 250,

MemoryActionPended = 350

}

#endregion Internal Members

#region Public Properties

/// <summary>

/// Return all process_pid

/// </summary>

static public string Log

{

get { return sLog; }

}

/// <summary>

/// Return all process_pid

/// </summary>

static public uint[] Processes_Pid

{

get { return iprocesses_pid; }

}

/// <summary>

/// Attached process_pid

/// </summary>

static public uint Process_Pid

{

get { return iPid; }

set { iPid = value; }

}

/// <summary>

/// Return all modules_prx_id

/// </summary>

static public int[] Modules_Prx_Id

{

get { return imodules_prx_id; }

}

/// <summary>

/// User Specified Timeout: Defaults to 5000 (5 seconds)

/// </summary>

static public int Timeout

{

get { return iTimeout; }

set { iTimeout = value; }

}

/// <summary>

/// Indicates if PS3MAPI is connected

/// </summary>

static public bool IsConnected

{

get { return ((main_sock != null) ? main_sock.Connected : false); }

}

/// <summary>

/// Indicates if PS3MAPI is attached

/// </summary>

static public bool IsAttached

{

get { return ((iPid != 0) ? true : false); }

}

#endregion Public Properties

//SERVER---------------------------------------------------------------------------------

internal static void Connect()

{

Connect(sServerIP, iPort);

}

internal static void Connect(string sServer, int Port)

{

sServerIP = sServer;

iPort = Port;

if (Port.ToString().Length == 0)

{

throw new Exception("Unable to Connect - No Port Specified.");

}

if (sServerIP.Length == 0)

{

throw new Exception("Unable to Connect - No Server Specified.");

}

if (main_sock != null)

{

if (main_sock.Connected)

{

return;

}

}

main_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

main_ipEndPoint = new IPEndPoint(Dns.GetHostByName(sServerIP).AddressList[0], Port);

try

{

main_sock.Connect(main_ipEndPoint);

}

catch (Exception ex)

{

throw new Exception(ex.Message, ex);

}

ReadResponse();

if (eResponseCode != PS3MAPI_ResponseCode.PS3MAPIConnected)

{

Fail();

}

ReadResponse();

if (eResponseCode != PS3MAPI_ResponseCode.PS3MAPIConnectedOK)

{

Fail();

}

if (Server_GetMinVersion() != ps3m_api_server_minversion)

{

Disconnect();

throw new Exception("PS3M_API_PC_LIB OUTDATED! PLEASE UPDATE.");

}

return;

}

internal static void Disconnect()

{

CloseDataSocket();

if (main_sock != null)

{

if (main_sock.Connected)

{

SendCommand("DISCONNECT");

iPid = 0;

main_sock.Close();

}

main_sock = null;

}

main_ipEndPoint = null;

}

internal static uint Server_Get_Version()

{

if (IsConnected)

{

SendCommand("SERVER GETVERSION");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return Convert.ToUInt32(sResponse);

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

internal static uint Server_GetMinVersion()

{

if (IsConnected)

{

SendCommand("SERVER GETMINVERSION");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return Convert.ToUInt32(sResponse);

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

//CORE-----------------------------------------------------------------------------------

internal static uint Core_Get_Version()

{

if (IsConnected)

{

SendCommand("CORE GETVERSION");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return Convert.ToUInt32(sResponse);

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

internal static uint Core_GetMinVersion()

{

if (IsConnected)

{

SendCommand("CORE GETMINVERSION");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return Convert.ToUInt32(sResponse);

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

//PS3------------------------------------------------------------------------------------

internal static uint PS3_GetFwVersion()

{

if (IsConnected)

{

SendCommand("PS3 GETFWVERSION");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return Convert.ToUInt32(sResponse);

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

internal static string PS3_GetFirmwareType()

{

if (IsConnected)

{

SendCommand("PS3 GETFWTYPE");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

break;

default:

Fail();

break;

}

return sResponse;

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

internal static void PS3_Shutdown()

{

if (IsConnected)

{

SendCommand("PS3 SHUTDOWN");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful:

case PS3MAPI_ResponseCode.CommandOK:

Disconnect();

break;

default:

Fail();

break;

}

}

else

{

throw new Exception("PS3MAPI not connected!");

}

}

internal static void PS3_Reboot()

{

if (IsConnected)

{

SendCommand("PS3 REBOOT");

switch (eResponseCode)

{

case PS3MAPI_ResponseCode.RequestSuccessful: