// Token: 0x06000225 RID: 549 RVA: 0x0000A09C File Offset: 0x0000829C
internal static string[] ReadValueNames(AmClusterRegkeyHandle handle)
{
List <string> list = new List <string>();
int num = 1024;
StringBuilder stringBuilder = new StringBuilder(num);
int num2 = 0;
int num6;
for (;;)
{
int num3 = num;
int num4 = 0;
int num5 = 0;
num6 = ClusapiMethods.ClusterRegEnumValue(handle, num2, stringBuilder, ref num3, ref num4, IntPtr.Zero, ref num5);
if (num6 != 0)
{
break;
}
string item = stringBuilder.ToString();
list.Add(item);
num2++;
}
if (num6 != 259)
{
throw AmExceptionHelper.ConstructClusterApiException(num6, "ClusterRegEnumValue()", new object[0]);
}
return(list.ToArray());
}
public IAmClusterResource CreateResource(string resName, string resType)
{
try
{
using (this.OwningCluster.OpenResource(resName))
{
throw new ClusResourceAlreadyExistsException(resName);
}
}
catch (ClusterApiException ex)
{
Win32Exception ex2 = ex.InnerException as Win32Exception;
if (ex2 != null && (long)ex2.NativeErrorCode != 5007L)
{
throw;
}
}
AmClusterResourceHandle amClusterResourceHandle = ClusapiMethods.CreateClusterResource(this.Handle, resName, resType, ClusterResourceCreateFlags.CLUSTER_RESOURCE_DEFAULT_MONITOR);
if (amClusterResourceHandle.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
throw AmExceptionHelper.ConstructClusterApiException(lastWin32Error, "CreateClusterResource(name={0},type={1})", new object[]
{
resName,
resType
});
}
return(new AmClusterResource(resName, this.OwningCluster, amClusterResourceHandle));
}
internal int CommitAndClose()
{
int num;
int result = ClusapiMethods.ClusterRegCloseBatch(this.handle, true, out num);
base.SetHandle(IntPtr.Zero);
return(result);
}
// Token: 0x06000224 RID: 548 RVA: 0x0000A060 File Offset: 0x00008260
internal static void Delete(string valueName, AmClusterRegkeyHandle handle)
{
int num = ClusapiMethods.ClusterRegDeleteValue(handle, valueName);
if (num != 2 && num != 3 && num != 1018 && num != 0)
{
throw AmExceptionHelper.ConstructClusterApiException(num, "ClusterRegDeleteValue()", new object[0]);
}
}
// Token: 0x060002F9 RID: 761 RVA: 0x0000D33C File Offset: 0x0000B53C
internal static int ClusterRegCloseKey(IntPtr RegKeyHandle, string name)
{
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegCloseKey, string.Format("KeyName = {0}, Handle = {1}", name, RegKeyHandle), delegate
{
retCode = ClusapiMethods.ClusterRegCloseKeyInternal(RegKeyHandle);
return(retCode);
});
return(retCode);
}
// Token: 0x06000239 RID: 569 RVA: 0x0000A550 File Offset: 0x00008750
public uint OfflineResource()
{
uint num = ClusapiMethods.OfflineClusterResource(this.Handle);
if (num != 0U)
{
ExTraceGlobals.ClusterTracer.TraceDebug <string, uint>((long)this.GetHashCode(), "OfflineClusterResource( '{0}' ) failed with 0x{1:x}", this.Name, num);
}
return(num);
}
// Token: 0x0600023A RID: 570 RVA: 0x0000A58C File Offset: 0x0000878C
public void DeleteResource()
{
string name = this.Name;
uint num = ClusapiMethods.DeleteClusterResource(this.Handle);
if (num != 0U)
{
throw AmExceptionHelper.ConstructClusterApiException((int)num, "DeleteClusterResource()", new object[0]);
}
}
// Token: 0x060002FD RID: 765 RVA: 0x0000D450 File Offset: 0x0000B650
internal static int ClusterRegBatchAddCommand([In] AmClusterBatchHandle hBatch, [In] CLUSTER_REG_COMMAND dwCommand, [MarshalAs(UnmanagedType.LPWStr)][In] string wzName, [In] RegistryValueKind dwOptions, [In] IntPtr lpData, [In] int cbData)
{
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegBatchAddCommand, string.Format("hBatch = {0} dwCommand = {1} wsName = {2}", hBatch, dwCommand, wzName), delegate
{
retCode = ClusapiMethods.ClusterRegBatchAddCommandInternal(hBatch, dwCommand, wzName, dwOptions, lpData, cbData);
return(retCode);
});
return(retCode);
}
// Token: 0x060002AD RID: 685 RVA: 0x0000CCE8 File Offset: 0x0000AEE8
internal static bool CloseCluster([In] IntPtr hCluster)
{
bool isSuccess = false;
ClusApiHook.CallBackDriver(ClusApiHooks.CloseCluster, string.Format("hCluster = {0}", hCluster), delegate
{
int result = 0;
isSuccess = ClusapiMethods.CloseClusterInternal(hCluster);
return(result);
});
return(isSuccess);
}
private void GetStateAndOwningNode(out AmGroupState state, out AmServerName nodeName)
{
int capacity = 260;
StringBuilder stringBuilder = new StringBuilder(capacity);
state = ClusapiMethods.GetClusterGroupState(this.m_handle, stringBuilder, ref capacity);
if (state == AmGroupState.Unknown)
{
throw new ClusterApiException("GetClusterGroupState() failed. State returned is Unknown.", new Win32Exception());
}
nodeName = new AmServerName(stringBuilder.ToString());
}
// Token: 0x060002FB RID: 763 RVA: 0x0000D3B4 File Offset: 0x0000B5B4
internal static int ClusterRegCreateBatch([In] AmClusterRegkeyHandle hKey, out AmClusterBatchHandle hBatch)
{
AmClusterBatchHandle hBatchTmp = null;
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegCreateBatch, string.Format("KeyName = {0}", hKey.Name), delegate
{
retCode = ClusapiMethods.ClusterRegCreateBatchInternal(hKey, out hBatchTmp);
return(retCode);
});
hBatch = hBatchTmp;
return(retCode);
}
// Token: 0x060002FF RID: 767 RVA: 0x0000D4FC File Offset: 0x0000B6FC
internal static int ClusterRegCloseBatch([In] IntPtr hBatch, [MarshalAs(UnmanagedType.Bool)][In] bool bCommit, [Optional] out int failedCommandNumber)
{
int failedCommandNumberTmp = 0;
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegCloseBatch, string.Format("hBatch = {0} bCommit = {1}", hBatch, bCommit), delegate
{
retCode = ClusapiMethods.ClusterRegCloseBatchInternal(hBatch, bCommit, out failedCommandNumberTmp);
return(retCode);
});
failedCommandNumber = failedCommandNumberTmp;
return(retCode);
}
// Token: 0x0600023C RID: 572 RVA: 0x0000A644 File Offset: 0x00008844
public uint SetDependencyExpression(string expression)
{
uint num = ClusapiMethods.SetClusterResourceDependencyExpression(this.Handle, expression);
if (num != 0U)
{
throw AmExceptionHelper.ConstructClusterApiException((int)num, "SetClusterResourceDependencyExpression({0})", new object[]
{
expression
});
}
return(num);
}
// Token: 0x060002F3 RID: 755 RVA: 0x0000D114 File Offset: 0x0000B314
internal static int ClusterRegQueryValue(AmClusterRegkeyHandle RegKeyHandle, string lpszValueName, out RegistryValueKind valueType, IntPtr lpbData, ref int lpcbData)
{
int lpcbDataTmp = lpcbData;
int valueTypeInt = 0;
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegQueryValue, string.Format("KeyName = {0} lpszValueName = {1}", RegKeyHandle.Name, lpszValueName), delegate
{
retCode = ClusapiMethods.ClusterRegQueryValueInternal(RegKeyHandle, lpszValueName, out valueTypeInt, lpbData, ref lpcbDataTmp);
return(retCode);
});
valueType = (RegistryValueKind)valueTypeInt;
lpcbData = lpcbDataTmp;
return(retCode);
}
internal void RegisterObject(SafeHandle clusObject, ClusterNotifyFlags eventMask, IntPtr context)
{
AmTrace.Debug("Registering additional cluster objects for notification", new object[0]);
int num = ClusapiMethods.RegisterClusterNotify(this.m_hChange, eventMask, clusObject, context);
if (num != 0)
{
AmTrace.Error("RegisterClusterNotify for group state returned error 0x{0:X8}", new object[]
{
num
});
throw AmExceptionHelper.ConstructClusterApiException(num, "RegisterClusterNotify(CLUSTER_CHANGE_GROUP_STATE)", new object[0]);
}
}
// Token: 0x06000215 RID: 533 RVA: 0x00009920 File Offset: 0x00007B20
public string ParseStringFromPropList(string propName)
{
string empty;
uint num = ClusapiMethods.ResUtilFindSzProperty(this.RawBuffer, this.BufferSize, propName, out empty);
if (num == 2U)
{
empty = string.Empty;
}
else if (num != 0U)
{
throw AmExceptionHelper.ConstructClusterApiException((int)num, "ResUtilFindSzProperty()", new object[0]);
}
return(empty);
}
// Token: 0x060001BE RID: 446 RVA: 0x00008438 File Offset: 0x00006638
private void SetNetworkControlData(AmClusterNetworkControlCode code, IntPtr buffer, uint bufferSize)
{
uint num = 0U;
int num2 = ClusapiMethods.ClusterNetworkControl(this.Handle, IntPtr.Zero, code, buffer, bufferSize, IntPtr.Zero, 0U, out num);
if (num2 != 0)
{
ClusterApiException ex = AmExceptionHelper.ConstructClusterApiException(num2, "ClusterNetworkControl(controlcode={0})", new object[]
{
code
});
AmClusterNetwork.Tracer.TraceDebug((long)this.GetHashCode(), ex.Message);
throw ex;
}
}
// Token: 0x06000214 RID: 532 RVA: 0x000098E0 File Offset: 0x00007AE0
public int ParseIntFromPropList(string propName)
{
uint result;
uint num = ClusapiMethods.ResUtilFindDwordProperty(this.RawBuffer, this.BufferSize, propName, out result);
if (num == 2U)
{
result = 0U;
}
else if (num != 0U)
{
throw AmExceptionHelper.ConstructClusterApiException((int)num, "ResUtilFindDwordProperty()", new object[0]);
}
return((int)result);
}
// Token: 0x06000244 RID: 580 RVA: 0x0000AAA4 File Offset: 0x00008CA4
private static IEnumerable <string> EnumerateObjects(AmClusterResourceHandle handle, AmClusterResourceEnum objectType)
{
new List <string>(16);
using (AmClusResourceEnumHandle enumHandle = ClusapiMethods.ClusterResourceOpenEnum(handle, objectType))
{
if (enumHandle.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
throw AmExceptionHelper.ConstructClusterApiException(lastWin32Error, "ClusterOpenResourceEnum(objecttype={0})", new object[]
{
objectType
});
}
int entryIndex = 0;
int objectNameLen = 256;
StringBuilder objectNameBuffer = new StringBuilder(objectNameLen);
int errorCode;
for (;;)
{
objectNameLen = objectNameBuffer.Capacity;
AmClusterResourceEnum objectTypeRetrived;
errorCode = ClusapiMethods.ClusterResourceEnum(enumHandle, entryIndex, out objectTypeRetrived, objectNameBuffer, ref objectNameLen);
if (errorCode == 259)
{
goto IL_171;
}
if (errorCode == 234)
{
objectNameBuffer.EnsureCapacity(objectNameLen);
}
else
{
if (errorCode != 0)
{
break;
}
if (objectTypeRetrived == objectType)
{
yield return(objectNameBuffer.ToString());
}
entryIndex++;
}
}
throw AmExceptionHelper.ConstructClusterApiException(errorCode, "ClusterResourceEnum()", new object[0]);
IL_171 :;
}
yield break;
}
// Token: 0x06000233 RID: 563 RVA: 0x0000A480 File Offset: 0x00008680
public AmResourceState GetState()
{
uint num = 0U;
uint num2 = 0U;
AmResourceState clusterResourceState = ClusapiMethods.GetClusterResourceState(this.Handle, null, ref num, null, ref num2);
if (clusterResourceState == AmResourceState.Unknown)
{
int lastWin32Error = Marshal.GetLastWin32Error();
throw AmExceptionHelper.ConstructClusterApiException(lastWin32Error, "GetClusterResourceState({0})", new object[]
{
this.Name
});
}
return(clusterResourceState);
}
// Token: 0x060002AB RID: 683 RVA: 0x0000CC70 File Offset: 0x0000AE70
internal static AmClusterHandle OpenCluster([In] string clusterName)
{
AmClusterHandle handle = null;
ClusApiHook.CallBackDriver(ClusApiHooks.OpenCluster, string.Format("clusterName = {0}", clusterName), delegate
{
int result = 0;
handle = ClusapiMethods.OpenClusterInternal(clusterName);
if (handle == null || handle.IsInvalid)
{
result = Marshal.GetLastWin32Error();
}
return(result);
});
return(handle);
}
// Token: 0x060002A4 RID: 676 RVA: 0x0000CB9C File Offset: 0x0000AD9C
public static int ClusterRegDeleteKey(AmClusterRegkeyHandle RegKeyHandle, string lpszSubKey)
{
AmClusterRegkeyHandle amClusterRegkeyHandle = null;
int retCode = ClusapiMethods.ClusterRegOpenKey(RegKeyHandle, lpszSubKey, RegSAM.Read, out amClusterRegkeyHandle);
if (retCode == 0)
{
amClusterRegkeyHandle.Dispose();
retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegDeleteKey, string.Format("RootKey = {0} Subkey = {1}", RegKeyHandle.Name, lpszSubKey), delegate
{
retCode = ClusapiMethods.ClusterRegDeleteKeyUnsafe(RegKeyHandle, lpszSubKey);
return(retCode);
});
}
return(retCode);
}
// Token: 0x060002F7 RID: 759 RVA: 0x0000D28C File Offset: 0x0000B48C
internal static int ClusterRegDeleteValue(AmClusterRegkeyHandle RegKeyHandle, string lpszValueName)
{
int num = 0;
RegistryValueKind registryValueKind;
int retCode = ClusapiMethods.ClusterRegQueryValue(RegKeyHandle, lpszValueName, out registryValueKind, IntPtr.Zero, ref num);
if (retCode == 0)
{
retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegDeleteValue, string.Format("KeyName = {0} lpszValueName = {1}", RegKeyHandle.Name, lpszValueName), delegate
{
retCode = ClusapiMethods.ClusterRegDeleteValueUnsafe(RegKeyHandle, lpszValueName);
return(retCode);
});
}
return(retCode);
}
// Token: 0x060002F5 RID: 757 RVA: 0x0000D1D0 File Offset: 0x0000B3D0
internal static int ClusterRegSetValue(AmClusterRegkeyHandle RegKeyHandle, string lpszValueName, RegistryValueKind dwType, IntPtr lpbData, int cbData)
{
string text = "ClusterRegSetValue";
string text2 = string.Format("KeyName = {0} lpszValueName = {1}", RegKeyHandle.Name, lpszValueName);
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegSetValue, text2, delegate
{
retCode = ClusapiMethods.ClusterRegSetValueInternal(RegKeyHandle, lpszValueName, dwType, lpbData, cbData);
return(retCode);
});
if (retCode != 0)
{
ReplayCrimsonEvents.CriticalClusterApiFailed.Log <string, string, int>(text, text2, retCode);
}
return(retCode);
}
// Token: 0x060002EF RID: 751 RVA: 0x0000CF50 File Offset: 0x0000B150
internal static int ClusterRegOpenKey(AmClusterRegkeyHandle RegKeyHandle, string lpszSubKey, RegSAM samDesired, out AmClusterRegkeyHandle phkResult)
{
AmClusterRegkeyHandle phkResultTmp = null;
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegOpenKey, string.Format("RootKeyName = {0} SubKey = {1}", RegKeyHandle.Name, lpszSubKey), delegate
{
retCode = ClusapiMethods.ClusterRegOpenKeyInternal(RegKeyHandle, lpszSubKey, samDesired, out phkResultTmp);
if (retCode == 0 && phkResultTmp != null)
{
phkResultTmp.Name = RegKeyHandle.Name + "\\" + lpszSubKey;
}
return(retCode);
});
phkResult = phkResultTmp;
return(retCode);
}
internal void Initialize(ClusterNotifyFlags eventMask, IntPtr context)
{
if (this.m_hChange == null || this.m_hChange.IsInvalid)
{
AmTrace.Debug("Creating cluster notification port", new object[0]);
this.m_hChange = ClusapiMethods.CreateClusterNotifyPort(AmClusterNotifyHandle.InvalidHandle, this.m_hCluster, eventMask, context);
if (this.m_hChange == null || this.m_hChange.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
AmTrace.Error("CreateClusterNotifyPort failed. Error code 0x{0:X8}", new object[]
{
lastWin32Error
});
throw AmExceptionHelper.ConstructClusterApiException(lastWin32Error, "CreateClusterNotifyPort()", new object[0]);
}
}
}
private bool CloseNotifyPort()
{
bool result = true;
lock (this)
{
if (!this.m_isClosed)
{
this.m_isClosed = true;
if (!this.IsInvalid)
{
AmTrace.Debug("Calling CloseClusterNotifyPort() (handle=0x{0:x})", new object[]
{
this.handle
});
try
{
result = ClusapiMethods.CloseClusterNotifyPort(this.handle);
goto IL_BD;
}
catch (AccessViolationException ex)
{
AmTrace.Error("Ignoring AccessViolationException exception while Closing cluster notify port (error={0})", new object[]
{
ex
});
goto IL_BD;
}
}
AmTrace.Debug("Skipped CloseClusterNotifyPort() since handle is invalid (handle=0x{0:x})", new object[]
{
this.handle
});
}
else
{
AmTrace.Debug("Skipped CloseClusterNotifyPort() the handle was closed already (handle=0x{0:x})", new object[]
{
this.handle
});
}
IL_BD :;
}
return(result);
}
// Token: 0x06000222 RID: 546 RVA: 0x00009ED0 File Offset: 0x000080D0
internal static object GetRaw(string valueName, AmClusterRegkeyHandle hKey, out bool doesValueExist)
{
IntPtr intPtr = IntPtr.Zero;
int num = 1024;
object result;
try
{
intPtr = Marshal.AllocHGlobal(num);
RegistryValueKind valueType;
int num2 = ClusapiMethods.ClusterRegQueryValue(hKey, valueName, out valueType, intPtr, ref num);
if (num2 == 234)
{
int num3 = 0;
do
{
Marshal.FreeHGlobal(intPtr);
intPtr = Marshal.AllocHGlobal(num);
num2 = ClusapiMethods.ClusterRegQueryValue(hKey, valueName, out valueType, intPtr, ref num);
}while (num2 == 234 && num3++ < 3);
}
if (num2 == 2 || num2 == 1018)
{
doesValueExist = false;
result = null;
}
else
{
if (num2 != 0)
{
throw AmExceptionHelper.ConstructClusterApiException(num2, "ClusterRegQueryValue()", new object[0]);
}
doesValueExist = true;
result = AmClusterRegProperty.ParseRegistryValue(valueType, intPtr, num);
}
}
finally
{
if (intPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(intPtr);
}
}
return(result);
}
public static AmClusterPropListDisposable CreatePropListString(string name, string value, out int bufferSize)
{
int num = 4 + AmClusPropListMaker.ClusPropValueSize(name) + AmClusPropListMaker.ClusPropValueSize(value) + 4;
int num2 = AmClusPropListMaker.PaddingSize(num, 4);
bufferSize = num + num2;
IntPtr intPtr = Marshal.AllocHGlobal(bufferSize);
string.Format("buffer is alloc'ed 0x{0:x} at 0x{1:x}", bufferSize, intPtr.ToInt64());
int num3 = 0;
num3 += AmClusPropListMaker.WriteHeader(intPtr, num3, 1);
num3 += AmClusPropListMaker.WriteStringValue(intPtr, num3, 262147, name);
num3 += AmClusPropListMaker.WriteStringValue(intPtr, num3, 65539, value);
num3 += AmClusPropListMaker.WriteTerminator(intPtr, num3);
ClusapiMethods.ResUtilVerifyPrivatePropertyList(intPtr, bufferSize);
return(new AmClusterPropListDisposable(new SafeHGlobalHandle(intPtr), (uint)bufferSize));
}
// Token: 0x060002F1 RID: 753 RVA: 0x0000D048 File Offset: 0x0000B248
internal static int ClusterRegCreateKey(AmClusterRegkeyHandle RegKeyHandle, string lpszSubKey, uint options, RegSAM samDesired, IntPtr securityAttributes, out AmClusterRegkeyHandle phkResult, out uint disposition)
{
AmClusterRegkeyHandle phkResultTmp = null;
uint dispositionTmp = 0U;
int retCode = ClusApiHook.CallBackDriver(ClusApiHooks.ClusterRegCreateKey, string.Format("RootKeyName = {0} SubKey = {1}", RegKeyHandle.Name, lpszSubKey), delegate
{
retCode = ClusapiMethods.ClusterRegCreateKeyInternal(RegKeyHandle, lpszSubKey, options, samDesired, securityAttributes, out phkResultTmp, out dispositionTmp);
if (retCode == 0 && phkResultTmp != null)
{
phkResultTmp.Name = RegKeyHandle.Name + "\\" + lpszSubKey;
}
return(retCode);
});
phkResult = phkResultTmp;
disposition = dispositionTmp;
return(retCode);
}