//
// Check cluster state status
//
int checkClusterState()
{
HCLUSTER hClust;
DWORD pdwClusterState;
if (GetNodeClusterState(NULL, &pdwClusterState) != ERROR_SUCCESS)
{
warnError(L"Error 0x%x executing GetClusterInformation entry point.", GetLastError());
return I_FALSE;
}
switch (pdwClusterState)
{
case ClusterStateNotInstalled :
warnError(L"Windows Clustering is not installed.");
return I_FALSE;
case ClusterStateNotConfigured :
warnError(L"Windows Clustering is not configured.");
return I_FALSE;
case ClusterStateNotRunning :
case ClusterStateRunning :
break ;
}
hClust = OpenCluster(NULL);
if (hClust == NULL)
{
warnError(L"Error 0x%x executing OpenCluster entry point.", GetLastError());
return I_FALSE;
}
CloseCluster(hClust);
return I_TRUE;
}
int getClusterGroups(cluster_t *pcluster)
{
HCLUSTER hClust;
HCLUSENUM hClusEnum;
DWORD dwIndex;
DWORD dwType;
LPWSTR lpszName;
DWORD cchName;
hClust = OpenCluster(NULL);
if (hClust == NULL)
{
warnError(L"Error 0x%x executing OpenCluster entry point.", GetLastError());
return I_FALSE;
}
if ((hClusEnum = ClusterOpenEnum(hClust, CLUSTER_ENUM_GROUP)) == NULL)
{
warnError(L"Error 0x%x executing OpenCluster entry point.", GetLastError());
CloseCluster(hClust);
return I_FALSE;
}
if ((lpszName = LocalAlloc(LPTR, BUFFER_SIZE * sizeof(TCHAR))) == NULL)
fatalError(L"Fatal Error 0x%x executing LocalAlloc entry point.", GetLastError());
cchName = BUFFER_SIZE;
for (dwIndex = 0; ClusterEnum(hClusEnum, dwIndex, &dwType, lpszName, &cchName) == ERROR_SUCCESS; dwIndex++)
{
getGroupState(pcluster, hClust, lpszName);
cchName = BUFFER_SIZE;
}
LocalFree(lpszName);
ClusterCloseEnum(hClusEnum);
CloseCluster(hClust);
return I_TRUE;
}
//_________________________________________________________
_CString::_CString (unsigned long sL, bool flag)
{
if (flag) {
sLength = 0;
if (sL<storageIncrement) {
sL = storageIncrement;
}
sData = (char*)MemAllocate (sL*sizeof (char));
allocatedSpace = sL;
if (!sData) {
warnError( -108);
}
} else {
allocatedSpace = 0;
sLength = sL;
sData = (char*)MemAllocate (sL+1);
if (sData) {
memset (sData,0,sL+1);
} else {
sLength = 0;
isError(0);
}
}
compressionType = NOCOMPRESSION;
}
void warnError (long errCode)
{
if (errCode == -108)
warnError (DecodeError (errCode)&_String(" Exiting..."));
else
WarnError (DecodeError (errCode)&_String(" Exiting..."));
}
int getGroupState(cluster_t *pcluster, HCLUSTER hClust, LPWSTR groupName)
{
HGROUP hGroup;
CLUSTER_GROUP_STATE groupState;
TCHAR lpszNodeName[BUFFER_SIZE];
DWORD cchNodeName;
cluster_group_t *group;
if ((hGroup = OpenClusterGroup(hClust, groupName)) == NULL)
{
warnError(L"Error 0x%x executing OpenCluster entry point.", GetLastError());
return I_FALSE;
}
cchNodeName = BUFFER_SIZE;
if ((groupState = GetClusterGroupState(hGroup, lpszNodeName, &cchNodeName)) == ClusterGroupStateUnknown)
{
warnError(L"Error 0x%x executing OpenCluster entry point.", GetLastError());
LocalFree(lpszNodeName);
CloseClusterGroup(hGroup);
return I_FALSE;
}
PDEBUG(L"Getting Group \"%s\"", groupName);
group = initClusterGroup(groupName, groupState);
wcsncpy(group->nodeName, lpszNodeName, BUFFER_SIZE - 1);
if (loadNodeName(group->savedNodeName, groupName))
group->hasSavedNode = I_TRUE;
if (group->hasSavedNode == I_TRUE && wcscmp(group->nodeName, group->savedNodeName) != 0)
{
group->bbState = USE_YELLOW;
createNodeChangedFile(group);
group->nodeHasChanged = I_TRUE;
}
if (isNodeChangedFileExists(group))
{
group->nodeHasChanged = I_TRUE;
group->bbState = USE_YELLOW;
}
if (group->bbState == USE_YELLOW)
pcluster->finalState = USE_YELLOW;
saveNodeName(lpszNodeName, groupName);
CloseClusterGroup(hGroup);
pcluster->groups[pcluster->countGroup] = group;
pcluster->countGroup++;
return I_TRUE;
}
//Element location functions (0,llength - 1)
long _SimpleList::operator () (const unsigned long i)
{
//if (lLength == 0) return 0;
//Is there a reason why this is commented out?
//if (i>=lLength) i = lLength-1;
if(i < lLength) {
return lData[i];
}
warnError("List index out of range");
return -1;
}
//_______________________________________________________________________
// append operator
void _CString::Finalize (void)
{
sData = MemReallocate (sData,sLength+1);
if (!sData) {
warnError(-108);
}
sData[sLength]=0;
allocatedSpace = 0;
}
int createNodeChangedFile(cluster_group_t *pGroupClust)
{
FILE *fp;
if ((fp = _wfopen(pGroupClust->nodeChangedFilePath, L"w")) == NULL)
{
warnError(L"Warning : can't open %s.", pGroupClust->nodeChangedFilePath);
return 1;
}
fwprintf(fp, L"%s", pGroupClust->savedNodeName);
fclose(fp);
return 0;
}
int saveNodeName(LPWSTR lpszNodeName, LPWSTR groupName)
{
FILE *fp;
static TCHAR lpPath[BUFFER_SIZE];
if (getTempPath((LPWSTR)lpPath) == 0)
fatalError(ERROR_GETTING_TEMP_PATH);
wcscat((LPWSTR)lpPath, SAVE_NODE_FILENAME);
wcscat((LPWSTR)lpPath, groupName);
wcscat((LPWSTR)lpPath, SAVE_NODE_FILENAME_EXTENSION);
if ((fp = _wfopen(lpPath, L"w")) == NULL)
{
warnError(L"Warning : can't open %s.", lpPath);
return 1;
}
fwprintf(fp, L"%s", lpszNodeName);
fclose(fp);
return 0;
}
_String* _CString::DecompressFrequency(void)
{
_String* theAlphabet = SelectAlpha (compressionType);
if (!IsFlag(FREQCOMPRESSION)) {
return nil; // wrong compression type nothing to do
}
unsigned char *codeMaps = new unsigned char [(*theAlphabet).sLength];
if (!codeMaps) {
warnError( -108); // no memory
}
unsigned int i,j,k,l,t; // temporary vars
// read in the alphabet encoding
i=0;
t=0;
for (j=0; j<(*theAlphabet).sLength; j++, i+=5, t = i/8) {
long leftover = 8-i%8;
unsigned char value = sData[t];
if (leftover>=5) {
switch (leftover) {
case 5:
value%=32;
break;
case 6:
value=(value%64)/2;
break;
case 7:
value=(value%128)/4;
break;
default:
value=value/8;
}
} else {
value=((unsigned char) sData[t])%realPowersOf2[leftover]*realPowersOf2[5-leftover];
value+=((unsigned char) sData[t+1])/realPowersOf2[3+leftover];
}
codeMaps[value-1]=j;
}
if(i%8) {
t++; //possible rounding error
}
// now read in the data
// first we must guess the correct size of the string, but to be safe we'll just set it to
// the maximum possible value (i.e. if all the bytes compressed to 1 bit)
_String result (10,true);
// k will count the actual length
// j,l will be used for relative positions of 0's
for (k=0,j=t*8;; ) { // go by bits
l=j; // look for the next zero bit in the stream
while (1) {
for (i=8-l%8; i>0; i--) {
if (!(sData[t]&realPowersOf2[i-1])) {
break;
}
}
if (i) {
l+=(8-i)-l%8;
break;
}
if (t<sLength-1) {
t++;
} else {
l=0;
break;
}
l=t*8;
}
if (!l) {
break;
}
l++;
_String addOn (theAlphabet->getChar(codeMaps[l-j-1]));
result<<&addOn;
if ((t=l/8)>=sLength) {
break;
}
j=l;
k++;
}
result.Finalize();
delete [] codeMaps;
return (_String*)(_String (result.getStr())).makeDynamic();
}
void checkPointer (void* p)
{
if (!p)
warnError(-108);
}
