using System;

using System.Collections.Generic;

using System.Runtime.InteropServices;

using System.Text;

public class PS3TMAPI

{

private static PS3TMAPI.EnumerateTargetsExCallbackPriv ms_enumTargetsExCallbackPriv = new PS3TMAPI.EnumerateTargetsExCallbackPriv(PS3TMAPI.EnumTargetsExPriv);

[ThreadStatic]

private static PS3TMAPI.EnumerateTargetsExCallback ms_enumTargetsExCallback = (PS3TMAPI.EnumerateTargetsExCallback)null;

[ThreadStatic]

private static object ms_enumTargetsExUserData = (object)null;

[ThreadStatic]

private static PS3TMAPI.ServerEventCallback ms_serverEventCallback = (PS3TMAPI.ServerEventCallback)null;

[ThreadStatic]

private static object ms_serverEventUserData = (object)null;

[ThreadStatic]

private static Dictionary<PS3TMAPI.TTYChannel, PS3TMAPI.TTYCallbackAndUserData> ms_userTtyCallbacks = (Dictionary<PS3TMAPI.TTYChannel, PS3TMAPI.TTYCallbackAndUserData>)null;

[ThreadStatic]

private static Dictionary<int, PS3TMAPI.PadPlaybackCallbackAndUserData> ms_userPadPlaybackCallbacks = (Dictionary<int, PS3TMAPI.PadPlaybackCallbackAndUserData>)null;

[ThreadStatic]

private static Dictionary<int, PS3TMAPI.PadCaptureCallbackAndUserData> ms_userPadCaptureCallbacks = (Dictionary<int, PS3TMAPI.PadCaptureCallbackAndUserData>)null;

private static PS3TMAPI.CustomProtocolCallbackPriv ms_customProtoCallbackPriv = new PS3TMAPI.CustomProtocolCallbackPriv(PS3TMAPI.CustomProtocolHandler);

[ThreadStatic]

private static Dictionary<PS3TMAPI.CustomProtocolId, PS3TMAPI.CusProtoCallbackAndUserData> ms_userCustomProtoCallbacks = (Dictionary<PS3TMAPI.CustomProtocolId, PS3TMAPI.CusProtoCallbackAndUserData>)null;

[ThreadStatic]

private static Dictionary<int, PS3TMAPI.FtpCallbackAndUserData> ms_userFtpCallbacks = (Dictionary<int, PS3TMAPI.FtpCallbackAndUserData>)null;

[ThreadStatic]

private static Dictionary<int, PS3TMAPI.FileTraceCallbackAndUserData> ms_userFileTraceCallbacks = (Dictionary<int, PS3TMAPI.FileTraceCallbackAndUserData>)null;

[ThreadStatic]

private static Dictionary<int, PS3TMAPI.TargetCallbackAndUserData> ms_userTargetCallbacks = (Dictionary<int, PS3TMAPI.TargetCallbackAndUserData>)null;

private static PS3TMAPI.HandleEventCallbackPriv ms_eventHandlerWrapper = new PS3TMAPI.HandleEventCallbackPriv(PS3TMAPI.EventHandlerWrapper);

public const int InvalidTarget = -1;

public const int DefaultTarget = -2;

public const uint AllTTYStreams = 4294967295;

public const uint DefaultProcessPriority = 999;

public const uint DefaultProtocolPriority = 128;

public static bool FAILED(PS3TMAPI.SNRESULT res)

{

return !PS3TMAPI.SUCCEEDED(res);

}

public static bool SUCCEEDED(PS3TMAPI.SNRESULT res)

{

return res >= PS3TMAPI.SNRESULT.SN_S_OK;

}

private static bool Is32Bit()

{

return IntPtr.Size == 4;

}

private static byte VersionMajor(ulong version)

{

return (byte)(version >> 16);

}

private static byte VersionMinor(ulong version)

{

return (byte)(version >> 8);

}

private static byte VersionFix(ulong version)

{

return (byte)version;

}

private static void VersionComponents(

ulong version,

out byte major,

out byte minor,

out byte fix)

{

major = PS3TMAPI.VersionMajor(version);

minor = PS3TMAPI.VersionMinor(version);

fix = PS3TMAPI.VersionFix(version);

}

public static byte SDKVersionMajor(ulong sdkVersion)

{

return PS3TMAPI.VersionMajor(sdkVersion);

}

public static byte SDKVersionMinor(ulong sdkVersion)

{

return PS3TMAPI.VersionMinor(sdkVersion);

}

public static byte SDKVersionFix(ulong sdkVersion)

{

return PS3TMAPI.VersionFix(sdkVersion);

}

public static void SDKVersionComponents(

ulong sdkVersion,

out byte major,

out byte minor,

out byte fix)

{

major = PS3TMAPI.SDKVersionMajor(sdkVersion);

minor = PS3TMAPI.SDKVersionMinor(sdkVersion);

fix = PS3TMAPI.SDKVersionFix(sdkVersion);

}

public static byte CPVersionMajor(ulong cpVersion)

{

return PS3TMAPI.VersionMajor(cpVersion);

}

public static byte CPVersionMinor(ulong cpVersion)

{

return PS3TMAPI.VersionMinor(cpVersion);

}

public static byte CPVersionFix(ulong cpVersion)

{

return PS3TMAPI.VersionFix(cpVersion);

}

public static void CPVersionComponents(

ulong cpVersion,

out byte major,

out byte minor,

out byte fix)

{

major = PS3TMAPI.CPVersionMajor(cpVersion);

minor = PS3TMAPI.CPVersionMinor(cpVersion);

fix = PS3TMAPI.CPVersionFix(cpVersion);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetTMVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTMVersionX86(out IntPtr version);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetTMVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTMVersionX64(out IntPtr version);

public static PS3TMAPI.SNRESULT GetTMVersion(out string version)

{

IntPtr version1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetTMVersionX86(out version1) : PS3TMAPI.GetTMVersionX64(out version1);

version = PS3TMAPI.Utf8ToString(version1, uint.MaxValue);

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetAPIVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetAPIVersionX86(out IntPtr version);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetAPIVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetAPIVersionX64(out IntPtr version);

public static PS3TMAPI.SNRESULT GetAPIVersion(out string version)

{

IntPtr version1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetAPIVersionX86(out version1) : PS3TMAPI.GetAPIVersionX64(out version1);

version = PS3TMAPI.Utf8ToString(version1, uint.MaxValue);

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3TranslateError", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT TranslateErrorX86(

PS3TMAPI.SNRESULT res,

out IntPtr message);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3TranslateError", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT TranslateErrorX64(

PS3TMAPI.SNRESULT res,

out IntPtr message);

public static PS3TMAPI.SNRESULT TranslateError(

PS3TMAPI.SNRESULT errorCode,

out string message)

{

IntPtr message1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.TranslateErrorX86(errorCode, out message1) : PS3TMAPI.TranslateErrorX64(errorCode, out message1);

message = PS3TMAPI.Utf8ToString(message1, uint.MaxValue);

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetErrorQualifier", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetErrorQualifierX86(

out uint qualifier,

out IntPtr message);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetErrorQualifier", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetErrorQualifierX64(

out uint qualifier,

out IntPtr message);

public static PS3TMAPI.SNRESULT GetErrorQualifier(out uint qualifier, out string message)

{

IntPtr message1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetErrorQualifierX86(out qualifier, out message1) : PS3TMAPI.GetErrorQualifierX64(out qualifier, out message1);

message = PS3TMAPI.Utf8ToString(message1, uint.MaxValue);

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetConnectStatus", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetConnectStatusX86(

int target,

out uint status,

out IntPtr usage);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetConnectStatus", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetConnectStatusX64(

int target,

out uint status,

out IntPtr usage);

public static PS3TMAPI.SNRESULT GetConnectStatus(

int target,

out PS3TMAPI.ConnectStatus status,

out string usage)

{

uint status1;

IntPtr usage1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetConnectStatusX86(target, out status1, out usage1) : PS3TMAPI.GetConnectStatusX64(target, out status1, out usage1);

status = (PS3TMAPI.ConnectStatus)status1;

usage = PS3TMAPI.Utf8ToString(usage1, uint.MaxValue);

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3InitTargetComms", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT InitTargetCommsX86();

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3InitTargetComms", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT InitTargetCommsX64();

public static PS3TMAPI.SNRESULT InitTargetComms()

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.InitTargetCommsX64();

return PS3TMAPI.InitTargetCommsX86();

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3CloseTargetComms", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT CloseTargetCommsX86();

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3CloseTargetComms", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT CloseTargetCommsX64();

public static PS3TMAPI.SNRESULT CloseTargetComms()

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.CloseTargetCommsX64();

return PS3TMAPI.CloseTargetCommsX86();

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3EnumerateTargets", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT EnumerateTargetsX86(

PS3TMAPI.EnumerateTargetsCallback callback);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3EnumerateTargets", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT EnumerateTargetsX64(

PS3TMAPI.EnumerateTargetsCallback callback);

public static PS3TMAPI.SNRESULT EnumerateTargets(

PS3TMAPI.EnumerateTargetsCallback callback)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.EnumerateTargetsX64(callback);

return PS3TMAPI.EnumerateTargetsX86(callback);

}

private static int EnumTargetsExPriv(int target, IntPtr unused)

{

if (PS3TMAPI.ms_enumTargetsExCallback == null)

return -1;

return PS3TMAPI.ms_enumTargetsExCallback(target, PS3TMAPI.ms_enumTargetsExUserData);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3EnumerateTargetsEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT EnumerateTargetsExX86(

PS3TMAPI.EnumerateTargetsExCallbackPriv callback,

IntPtr unused);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3EnumerateTargetsEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT EnumerateTargetsExX64(

PS3TMAPI.EnumerateTargetsExCallbackPriv callback,

IntPtr unused);

public static PS3TMAPI.SNRESULT EnumerateTargetsEx(

PS3TMAPI.EnumerateTargetsExCallback callback,

ref object userData)

{

if (callback == null)

return PS3TMAPI.SNRESULT.SN_E_BAD_PARAM;

PS3TMAPI.ms_enumTargetsExCallback = callback;

PS3TMAPI.ms_enumTargetsExUserData = userData;

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.EnumerateTargetsExX64(PS3TMAPI.ms_enumTargetsExCallbackPriv, IntPtr.Zero);

return PS3TMAPI.EnumerateTargetsExX86(PS3TMAPI.ms_enumTargetsExCallbackPriv, IntPtr.Zero);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetNumTargets", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetNumTargetsX86(out uint numTargets);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetNumTargets", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetNumTargetsX64(out uint numTargets);

public static PS3TMAPI.SNRESULT GetNumTargets(out uint numTargets)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetNumTargetsX64(out numTargets);

return PS3TMAPI.GetNumTargetsX86(out numTargets);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetTargetFromName", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTargetFromNameX86(IntPtr name, out int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetTargetFromName", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTargetFromNameX64(IntPtr name, out int target);

public static PS3TMAPI.SNRESULT GetTargetFromName(string name, out int target)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(name));

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetTargetFromNameX64(scopedGlobalHeapPtr.Get(), out target);

return PS3TMAPI.GetTargetFromNameX86(scopedGlobalHeapPtr.Get(), out target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3Reset", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ResetX86(int target, ulong resetParameter);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3Reset", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ResetX64(int target, ulong resetParameter);

public static PS3TMAPI.SNRESULT Reset(int target, PS3TMAPI.ResetParameter resetParameter)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.ResetX64(target, (ulong)resetParameter);

return PS3TMAPI.ResetX86(target, (ulong)resetParameter);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3ResetEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ResetExX86(

int target,

ulong boot,

ulong bootMask,

ulong reset,

ulong resetMask,

ulong system,

ulong systemMask);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3ResetEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ResetExX64(

int target,

ulong boot,

ulong bootMask,

ulong reset,

ulong resetMask,

ulong system,

ulong systemMask);

public static PS3TMAPI.SNRESULT ResetEx(

int target,

PS3TMAPI.BootParameter bootParameter,

PS3TMAPI.BootParameterMask bootMask,

PS3TMAPI.ResetParameter resetParameter,

PS3TMAPI.ResetParameterMask resetMask,

PS3TMAPI.SystemParameter systemParameter,

PS3TMAPI.SystemParameterMask systemMask)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.ResetExX64(target, (ulong)bootParameter, (ulong)bootMask, (ulong)resetParameter, (ulong)resetMask, (ulong)systemParameter, (ulong)systemMask);

return PS3TMAPI.ResetExX86(target, (ulong)bootParameter, (ulong)bootMask, (ulong)resetParameter, (ulong)resetMask, (ulong)systemParameter, (ulong)systemMask);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetResetParameters", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetResetParametersX86(

int target,

out ulong boot,

out ulong bootMask,

out ulong reset,

out ulong resetMask,

out ulong system,

out ulong systemMask);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetResetParameters", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetResetParametersX64(

int target,

out ulong boot,

out ulong bootMask,

out ulong reset,

out ulong resetMask,

out ulong system,

out ulong systemMask);

public static PS3TMAPI.SNRESULT GetResetParameters(

int target,

out PS3TMAPI.BootParameter bootParameter,

out PS3TMAPI.BootParameterMask bootMask,

out PS3TMAPI.ResetParameter resetParameter,

out PS3TMAPI.ResetParameterMask resetMask,

out PS3TMAPI.SystemParameter systemParameter,

out PS3TMAPI.SystemParameterMask systemMask)

{

ulong boot;

ulong bootMask1;

ulong reset;

ulong resetMask1;

ulong system;

ulong systemMask1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetResetParametersX86(target, out boot, out bootMask1, out reset, out resetMask1, out system, out systemMask1) : PS3TMAPI.GetResetParametersX64(target, out boot, out bootMask1, out reset, out resetMask1, out system, out systemMask1);

bootParameter = (PS3TMAPI.BootParameter)boot;

bootMask = (PS3TMAPI.BootParameterMask)bootMask1;

resetParameter = (PS3TMAPI.ResetParameter)reset;

resetMask = (PS3TMAPI.ResetParameterMask)resetMask1;

systemParameter = (PS3TMAPI.SystemParameter)system;

systemMask = (PS3TMAPI.SystemParameterMask)systemMask1;

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetBootParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetBootParameterX86(

int target,

ulong boot,

ulong bootMask);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetBootParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetBootParameterX64(

int target,

ulong boot,

ulong bootMask);

public static PS3TMAPI.SNRESULT SetBootParameter(

int target,

PS3TMAPI.BootParameter bootParameter,

PS3TMAPI.BootParameterMask bootMask)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetBootParameterX64(target, (ulong)bootParameter, (ulong)bootMask);

return PS3TMAPI.SetBootParameterX86(target, (ulong)bootParameter, (ulong)bootMask);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetCurrentBootParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetCurrentBootParameterX86(

int target,

out ulong boot);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetCurrentBootParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetCurrentBootParameterX64(

int target,

out ulong boot);

public static PS3TMAPI.SNRESULT GetCurrentBootParameter(

int target,

out PS3TMAPI.BootParameter bootParameter)

{

ulong boot;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetCurrentBootParameterX86(target, out boot) : PS3TMAPI.GetCurrentBootParameterX64(target, out boot);

bootParameter = (PS3TMAPI.BootParameter)boot;

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetSystemParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetSystemParameterX86(

int target,

ulong system,

ulong systemMask);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetSystemParameter", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetSystemParameterX64(

int target,

ulong system,

ulong systemMask);

public static PS3TMAPI.SNRESULT SetSystemParameter(

int target,

PS3TMAPI.SystemParameter systemParameter,

PS3TMAPI.SystemParameterMask systemMask)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetSystemParameterX64(target, (ulong)systemParameter, (ulong)systemMask);

return PS3TMAPI.SetSystemParameterX86(target, (ulong)systemParameter, (ulong)systemMask);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetTargetInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTargetInfoX86(

ref PS3TMAPI.TargetInfoPriv targetInfoPriv);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetTargetInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTargetInfoX64(

ref PS3TMAPI.TargetInfoPriv targetInfoPriv);

public static PS3TMAPI.SNRESULT GetTargetInfo(ref PS3TMAPI.TargetInfo targetInfo)

{

PS3TMAPI.TargetInfoPriv targetInfoPriv = new PS3TMAPI.TargetInfoPriv();

targetInfoPriv.Flags = targetInfo.Flags;

targetInfoPriv.Target = targetInfo.Target;

PS3TMAPI.SNRESULT res = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetTargetInfoX86(ref targetInfoPriv) : PS3TMAPI.GetTargetInfoX64(ref targetInfoPriv);

if (PS3TMAPI.FAILED(res))

return res;

targetInfo.Flags = targetInfoPriv.Flags;

targetInfo.Target = targetInfoPriv.Target;

targetInfo.Name = PS3TMAPI.Utf8ToString(targetInfoPriv.Name, uint.MaxValue);

targetInfo.Type = PS3TMAPI.Utf8ToString(targetInfoPriv.Type, uint.MaxValue);

targetInfo.Info = PS3TMAPI.Utf8ToString(targetInfoPriv.Info, uint.MaxValue);

targetInfo.HomeDir = PS3TMAPI.Utf8ToString(targetInfoPriv.HomeDir, uint.MaxValue);

targetInfo.FSDir = PS3TMAPI.Utf8ToString(targetInfoPriv.FSDir, uint.MaxValue);

targetInfo.Boot = targetInfoPriv.Boot;

return res;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetTargetInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetTargetInfoX86(ref PS3TMAPI.TargetInfoPriv info);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetTargetInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetTargetInfoX64(ref PS3TMAPI.TargetInfoPriv info);

public static PS3TMAPI.SNRESULT SetTargetInfo(PS3TMAPI.TargetInfo targetInfo)

{

PS3TMAPI.TargetInfoPriv info = new PS3TMAPI.TargetInfoPriv();

info.Flags = targetInfo.Flags;

info.Target = targetInfo.Target;

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr1 = new PS3TMAPI.ScopedGlobalHeapPtr(IntPtr.Zero);

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr2 = new PS3TMAPI.ScopedGlobalHeapPtr(IntPtr.Zero);

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr3 = new PS3TMAPI.ScopedGlobalHeapPtr(IntPtr.Zero);

if ((targetInfo.Flags & PS3TMAPI.TargetInfoFlag.Name) > (PS3TMAPI.TargetInfoFlag)0)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr4 = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(targetInfo.Name));

info.Name = scopedGlobalHeapPtr4.Get();

}

if ((targetInfo.Flags & PS3TMAPI.TargetInfoFlag.HomeDir) > (PS3TMAPI.TargetInfoFlag)0)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr4 = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(targetInfo.HomeDir));

info.HomeDir = scopedGlobalHeapPtr4.Get();

}

if ((targetInfo.Flags & PS3TMAPI.TargetInfoFlag.FileServingDir) > (PS3TMAPI.TargetInfoFlag)0)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr4 = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(targetInfo.FSDir));

info.FSDir = scopedGlobalHeapPtr4.Get();

}

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetTargetInfoX64(ref info);

return PS3TMAPI.SetTargetInfoX86(ref info);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3ListTargetTypes", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ListTargetTypesX86(

ref uint size,

IntPtr targetTypes);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3ListTargetTypes", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ListTargetTypesX64(

ref uint size,

IntPtr targetTypes);

public static PS3TMAPI.SNRESULT ListTargetTypes(out PS3TMAPI.TargetType[] targetTypes)

{

targetTypes = (PS3TMAPI.TargetType[])null;

uint size = 0;

PS3TMAPI.SNRESULT res1 = PS3TMAPI.Is32Bit() ? PS3TMAPI.ListTargetTypesX86(ref size, IntPtr.Zero) : PS3TMAPI.ListTargetTypesX64(ref size, IntPtr.Zero);

if (PS3TMAPI.FAILED(res1))

return res1;

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr = new PS3TMAPI.ScopedGlobalHeapPtr(Marshal.AllocHGlobal((int)((long)Marshal.SizeOf(typeof(PS3TMAPI.TargetType)) * (long)size)));

PS3TMAPI.SNRESULT res2 = PS3TMAPI.Is32Bit() ? PS3TMAPI.ListTargetTypesX86(ref size, scopedGlobalHeapPtr.Get()) : PS3TMAPI.ListTargetTypesX64(ref size, scopedGlobalHeapPtr.Get());

if (PS3TMAPI.FAILED(res2))

return res2;

IntPtr size1 = (IntPtr)size;

targetTypes = new PS3TMAPI.TargetType[(int)size1];

IntPtr utf8Ptr = scopedGlobalHeapPtr.Get();

for (uint index = 0; index < size; ++index)

{

IntPtr index1 = (IntPtr)index;

targetTypes[(int)index1].Type = PS3TMAPI.Utf8ToString(utf8Ptr, 64U);

utf8Ptr = new IntPtr(utf8Ptr.ToInt64() + 64L);

targetTypes[(int)index1].Description = PS3TMAPI.Utf8ToString(utf8Ptr, 256U);

utf8Ptr = new IntPtr(utf8Ptr.ToInt64() + 256L);

}

return res2;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3AddTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT AddTargetX86(

IntPtr name,

IntPtr type,

int connParamsSize,

IntPtr connectParams,

out int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3AddTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT AddTargetX64(

IntPtr name,

IntPtr type,

int connParamsSize,

IntPtr connectParams,

out int target);

public static PS3TMAPI.SNRESULT AddTarget(

string name,

string targetType,

PS3TMAPI.TCPIPConnectProperties connectProperties,

out int target)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr1 = new PS3TMAPI.ScopedGlobalHeapPtr(IntPtr.Zero);

int num = 0;

if (connectProperties != null)

{

num = Marshal.SizeOf((object)connectProperties);

scopedGlobalHeapPtr1 = new PS3TMAPI.ScopedGlobalHeapPtr(Marshal.AllocHGlobal(num));

Marshal.StructureToPtr((object)connectProperties, scopedGlobalHeapPtr1.Get(), false);

}

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr2 = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(name));

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr3 = new PS3TMAPI.ScopedGlobalHeapPtr(PS3TMAPI.AllocUtf8FromString(targetType));

return PS3TMAPI.Is32Bit() ? PS3TMAPI.AddTargetX86(scopedGlobalHeapPtr2.Get(), scopedGlobalHeapPtr3.Get(), num, scopedGlobalHeapPtr1.Get(), out target) : PS3TMAPI.AddTargetX64(scopedGlobalHeapPtr2.Get(), scopedGlobalHeapPtr3.Get(), num, scopedGlobalHeapPtr1.Get(), out target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetDefaultTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetDefaultTargetX86(int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetDefaultTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetDefaultTargetX64(int target);

public static PS3TMAPI.SNRESULT SetDefaultTarget(int target)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetDefaultTargetX64(target);

return PS3TMAPI.SetDefaultTargetX86(target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetDefaultTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetDefaultTargetX86(out int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetDefaultTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetDefaultTargetX64(out int target);

public static PS3TMAPI.SNRESULT GetDefaultTarget(out int target)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetDefaultTargetX64(out target);

return PS3TMAPI.GetDefaultTargetX86(out target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3RegisterServerEventHandler", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT RegisterServerEventHandlerX86(

PS3TMAPI.HandleEventCallbackPriv callback,

IntPtr userData);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3RegisterServerEventHandler", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT RegisterServerEventHandlerX64(

PS3TMAPI.HandleEventCallbackPriv callback,

IntPtr userData);

public static PS3TMAPI.SNRESULT RegisterServerEventHandler(

PS3TMAPI.ServerEventCallback callback,

ref object userData)

{

if (callback == null)

return PS3TMAPI.SNRESULT.SN_E_BAD_PARAM;

PS3TMAPI.SNRESULT res = PS3TMAPI.Is32Bit() ? PS3TMAPI.RegisterServerEventHandlerX86(PS3TMAPI.ms_eventHandlerWrapper, IntPtr.Zero) : PS3TMAPI.RegisterServerEventHandlerX64(PS3TMAPI.ms_eventHandlerWrapper, IntPtr.Zero);

if (PS3TMAPI.SUCCEEDED(res))

{

PS3TMAPI.ms_serverEventCallback = callback;

PS3TMAPI.ms_serverEventUserData = userData;

}

return res;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3UnRegisterServerEventHandler", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT UnregisterServerEventHandlerX86();

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3UnRegisterServerEventHandler", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT UnregisterServerEventHandlerX64();

public static PS3TMAPI.SNRESULT UnregisterServerEventHandler()

{

PS3TMAPI.SNRESULT res = PS3TMAPI.Is32Bit() ? PS3TMAPI.UnregisterServerEventHandlerX86() : PS3TMAPI.UnregisterServerEventHandlerX64();

if (PS3TMAPI.SUCCEEDED(res))

{

PS3TMAPI.ms_serverEventCallback = (PS3TMAPI.ServerEventCallback)null;

PS3TMAPI.ms_serverEventUserData = (object)null;

}

return res;

}

private static void MarshalServerEvent(

int target,

uint param,

PS3TMAPI.SNRESULT result,

uint length,

IntPtr data)

{

if (PS3TMAPI.ms_serverEventCallback == null)

return;

PS3TMAPI.ServerEventHeader storage = new PS3TMAPI.ServerEventHeader();

PS3TMAPI.ReadDataFromUnmanagedIncPtr<PS3TMAPI.ServerEventHeader>(data, ref storage);

PS3TMAPI.ms_serverEventCallback(target, result, storage.eventType, PS3TMAPI.ms_serverEventUserData);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetConnectionInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetConnectionInfoX86(

int target,

IntPtr connectProperties);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetConnectionInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetConnectionInfoX64(

int target,

IntPtr connectProperties);

public static PS3TMAPI.SNRESULT GetConnectionInfo(

int target,

out PS3TMAPI.TCPIPConnectProperties connectProperties)

{

connectProperties = (PS3TMAPI.TCPIPConnectProperties)null;

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr = new PS3TMAPI.ScopedGlobalHeapPtr(Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PS3TMAPI.TCPIPConnectProperties))));

PS3TMAPI.SNRESULT res = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetConnectionInfoX86(target, scopedGlobalHeapPtr.Get()) : PS3TMAPI.GetConnectionInfoX64(target, scopedGlobalHeapPtr.Get());

if (PS3TMAPI.SUCCEEDED(res))

{

connectProperties = new PS3TMAPI.TCPIPConnectProperties();

Marshal.PtrToStructure(scopedGlobalHeapPtr.Get(), (object)connectProperties);

}

return res;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetConnectionInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetConnectionInfoX86(

int target,

IntPtr connectProperties);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetConnectionInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetConnectionInfoX64(

int target,

IntPtr connectProperties);

public static PS3TMAPI.SNRESULT SetConnectionInfo(

int target,

PS3TMAPI.TCPIPConnectProperties connectProperties)

{

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr = new PS3TMAPI.ScopedGlobalHeapPtr(Marshal.AllocHGlobal(Marshal.SizeOf((object)connectProperties)));

PS3TMAPI.WriteDataToUnmanagedIncPtr<PS3TMAPI.TCPIPConnectProperties>(connectProperties, scopedGlobalHeapPtr.Get());

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetConnectionInfoX64(target, scopedGlobalHeapPtr.Get());

return PS3TMAPI.SetConnectionInfoX86(target, scopedGlobalHeapPtr.Get());

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3DeleteTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT DeleteTargetX86(int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3DeleteTarget", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT DeleteTargetX64(int target);

public static PS3TMAPI.SNRESULT DeleteTarget(int target)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.DeleteTargetX64(target);

return PS3TMAPI.DeleteTargetX86(target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3Connect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ConnectX86(int target, string application);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3Connect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ConnectX64(int target, string application);

public static PS3TMAPI.SNRESULT Connect(int target, string application)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.ConnectX64(target, application);

return PS3TMAPI.ConnectX86(target, application);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3ConnectEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ConnectExX86(

int target,

string application,

bool bForceFlag);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3ConnectEx", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ConnectExX64(

int target,

string application,

bool bForceFlag);

public static PS3TMAPI.SNRESULT ConnectEx(

int target,

string application,

bool bForceFlag)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.ConnectExX64(target, application, bForceFlag);

return PS3TMAPI.ConnectExX86(target, application, bForceFlag);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3Disconnect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT DisconnectX86(int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3Disconnect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT DisconnectX64(int target);

public static PS3TMAPI.SNRESULT Disconnect(int target)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.DisconnectX64(target);

return PS3TMAPI.DisconnectX86(target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3ForceDisconnect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ForceDisconnectX86(int target);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3ForceDisconnect", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ForceDisconnectX64(int target);

public static PS3TMAPI.SNRESULT ForceDisconnect(int target)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.ForceDisconnectX64(target);

return PS3TMAPI.ForceDisconnectX86(target);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetSystemInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetSystemInfoX86(

int target,

uint reserved,

out uint mask,

out PS3TMAPI.SystemInfo info);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetSystemInfo", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetSystemInfoX64(

int target,

uint reserved,

out uint mask,

out PS3TMAPI.SystemInfo info);

public static PS3TMAPI.SNRESULT GetSystemInfo(

int target,

out PS3TMAPI.SystemInfoFlag mask,

out PS3TMAPI.SystemInfo systemInfo)

{

systemInfo = new PS3TMAPI.SystemInfo();

uint mask1;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetSystemInfoX86(target, 0U, out mask1, out systemInfo) : PS3TMAPI.GetSystemInfoX64(target, 0U, out mask1, out systemInfo);

mask = (PS3TMAPI.SystemInfoFlag)mask1;

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetExtraLoadFlags", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetExtraLoadFlagsX86(

int target,

out ulong extraLoadFlags);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetExtraLoadFlags", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetExtraLoadFlagsX64(

int target,

out ulong extraLoadFlags);

public static PS3TMAPI.SNRESULT GetExtraLoadFlags(

int target,

out PS3TMAPI.ExtraLoadFlag extraLoadFlags)

{

ulong extraLoadFlags1 = 0;

PS3TMAPI.SNRESULT snresult = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetExtraLoadFlagsX86(target, out extraLoadFlags1) : PS3TMAPI.GetExtraLoadFlagsX64(target, out extraLoadFlags1);

extraLoadFlags = (PS3TMAPI.ExtraLoadFlag)extraLoadFlags1;

return snresult;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetExtraLoadFlags", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetExtraLoadFlagsX86(

int target,

ulong extraLoadFlags,

ulong mask);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetExtraLoadFlags", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetExtraLoadFlagsX64(

int target,

ulong extraLoadFlags,

ulong mask);

public static PS3TMAPI.SNRESULT SetExtraLoadFlags(

int target,

PS3TMAPI.ExtraLoadFlag extraLoadFlags,

PS3TMAPI.ExtraLoadFlagMask mask)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetExtraLoadFlagsX64(target, (ulong)extraLoadFlags, (ulong)mask);

return PS3TMAPI.SetExtraLoadFlagsX86(target, (ulong)extraLoadFlags, (ulong)mask);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetSDKVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetSDKVersionX86(int target, out ulong sdkVersion);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetSDKVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetSDKVersionX64(int target, out ulong sdkVersion);

public static PS3TMAPI.SNRESULT GetSDKVersion(int target, out ulong sdkVersion)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetSDKVersionX64(target, out sdkVersion);

return PS3TMAPI.GetSDKVersionX86(target, out sdkVersion);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetCPVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetCPVersionX86(int target, out ulong cpVersion);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetCPVersion", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetCPVersionX64(int target, out ulong cpVersion);

public static PS3TMAPI.SNRESULT GetCPVersion(int target, out ulong cpVersion)

{

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetCPVersionX64(target, out cpVersion);

return PS3TMAPI.GetCPVersionX86(target, out cpVersion);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3SetTimeouts", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetTimeoutsX86(

int target,

uint numTimeouts,

PS3TMAPI.TimeoutType[] timeoutIds,

uint[] timeoutValues);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3SetTimeouts", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT SetTimeoutsX64(

int target,

uint numTimeouts,

PS3TMAPI.TimeoutType[] timeoutIds,

uint[] timeoutValues);

public static PS3TMAPI.SNRESULT SetTimeouts(

int target,

PS3TMAPI.TimeoutType[] timeoutTypes,

uint[] timeoutValues)

{

if (timeoutTypes == null || timeoutTypes.Length < 1 || (timeoutValues == null || timeoutValues.Length != timeoutTypes.Length))

return PS3TMAPI.SNRESULT.SN_E_BAD_PARAM;

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.SetTimeoutsX64(target, (uint)timeoutTypes.Length, timeoutTypes, timeoutValues);

return PS3TMAPI.SetTimeoutsX86(target, (uint)timeoutTypes.Length, timeoutTypes, timeoutValues);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3GetTimeouts", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTimeoutsX86(

int target,

out uint numTimeouts,

PS3TMAPI.TimeoutType[] timeoutIds,

uint[] timeoutValues);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3GetTimeouts", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT GetTimeoutsX64(

int target,

out uint numTimeouts,

PS3TMAPI.TimeoutType[] timeoutIds,

uint[] timeoutValues);

public static PS3TMAPI.SNRESULT GetTimeouts(

int target,

out PS3TMAPI.TimeoutType[] timeoutTypes,

out uint[] timeoutValues)

{

timeoutTypes = (PS3TMAPI.TimeoutType[])null;

timeoutValues = (uint[])null;

uint numTimeouts;

PS3TMAPI.SNRESULT res = PS3TMAPI.Is32Bit() ? PS3TMAPI.GetTimeoutsX86(target, out numTimeouts, (PS3TMAPI.TimeoutType[])null, (uint[])null) : PS3TMAPI.GetTimeoutsX64(target, out numTimeouts, (PS3TMAPI.TimeoutType[])null, (uint[])null);

if (PS3TMAPI.FAILED(res))

return res;

timeoutTypes = new PS3TMAPI.TimeoutType[(int)(IntPtr)numTimeouts];

timeoutValues = new uint[(int)(IntPtr)numTimeouts];

if (!PS3TMAPI.Is32Bit())

return PS3TMAPI.GetTimeoutsX64(target, out numTimeouts, timeoutTypes, timeoutValues);

return PS3TMAPI.GetTimeoutsX86(target, out numTimeouts, timeoutTypes, timeoutValues);

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3ListTTYStreams", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ListTtyStreamsX86(

int target,

ref uint size,

IntPtr streamArray);

[DllImport("PS3TMAPIX64.dll", EntryPoint = "SNPS3ListTTYStreams", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT ListTtyStreamsX64(

int target,

ref uint size,

IntPtr streamArray);

public static PS3TMAPI.SNRESULT ListTTYStreams(

int target,

out PS3TMAPI.TTYStream[] streamArray)

{

streamArray = (PS3TMAPI.TTYStream[])null;

uint size = 0;

PS3TMAPI.SNRESULT res1 = PS3TMAPI.Is32Bit() ? PS3TMAPI.ListTtyStreamsX86(target, ref size, IntPtr.Zero) : PS3TMAPI.ListTtyStreamsX64(target, ref size, IntPtr.Zero);

if (PS3TMAPI.FAILED(res1))

return res1;

PS3TMAPI.ScopedGlobalHeapPtr scopedGlobalHeapPtr = new PS3TMAPI.ScopedGlobalHeapPtr(Marshal.AllocHGlobal((int)((long)Marshal.SizeOf(typeof(PS3TMAPI.TTYStream)) * (long)size)));

PS3TMAPI.SNRESULT res2 = PS3TMAPI.Is32Bit() ? PS3TMAPI.ListTtyStreamsX86(target, ref size, scopedGlobalHeapPtr.Get()) : PS3TMAPI.ListTtyStreamsX64(target, ref size, scopedGlobalHeapPtr.Get());

if (PS3TMAPI.FAILED(res2))

return res2;

IntPtr unmanagedBuf = scopedGlobalHeapPtr.Get();

streamArray = new PS3TMAPI.TTYStream[(int)(IntPtr)size];

for (uint index = 0; index < size; ++index)

unmanagedBuf = PS3TMAPI.ReadDataFromUnmanagedIncPtr<PS3TMAPI.TTYStream>(unmanagedBuf, ref streamArray[(int)(IntPtr)index]);

return res2;

}

[DllImport("PS3TMAPI.dll", EntryPoint = "SNPS3RegisterTTYEventHandler", CallingConvention = CallingConvention.Cdecl)]

private static extern PS3TMAPI.SNRESULT RegisterTtyEventHandlerX86(

int target,

uint streamIndex,

PS3TMAPI.HandleEventCallbackPriv callback,

IntPtr userData);