978 lines
26 KiB
C
978 lines
26 KiB
C
/*
|
|
|
|
PROGRAM: grptoreg
|
|
|
|
PURPOSE: Move the Program Manager's group files (*.GRP) to the
|
|
registry. Also updates the Program Manager's settings that are
|
|
in progman.ini.
|
|
|
|
This program needs to be run in the directory where the .grp
|
|
and progman.ini files reside. It uses progman.ini to update the
|
|
registry, only the group files named in progman.ini will
|
|
be entered into the registry.
|
|
|
|
Once this program is run, all that needs to be done is:
|
|
Logoff, then logon again.
|
|
|
|
FUNCTIONS:
|
|
|
|
COMMENTS:
|
|
Most of the functions were extracted from the Program Manager.
|
|
If the group fromat changes in the Progam Manager, the same
|
|
changes must be done here (and in grptoreg.h). Same thing
|
|
applies where in the registry this information is to be
|
|
stored/read.
|
|
|
|
|
|
MODIFICATION HISTORY
|
|
Created: 4/10/92 JohanneC
|
|
|
|
*/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include "grptoreg.h"
|
|
|
|
BOOL SaveGroupInRegistry(PGROUP pGroup, BOOL bCommonGrp, BOOL bOverwriteGroup);
|
|
|
|
|
|
|
|
/* MyDwordAlign() - */
|
|
|
|
|
|
|
|
INT MyDwordAlign(INT wStrLen)
|
|
{
|
|
return ((wStrLen + 3) & ~3);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* SizeofGroup_U() - for unicode groups */
|
|
|
|
|
|
DWORD PASCAL SizeofGroup_U(LPGROUPDEF_U lpgd)
|
|
{
|
|
LPPMTAG lptag;
|
|
DWORD cbSeg;
|
|
DWORD cb;
|
|
|
|
cbSeg = GlobalSize(lpgd);
|
|
|
|
lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);
|
|
|
|
if ((DWORD)((PCHAR)lptag - (PCHAR)lpgd +MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))+4) <= cbSeg
|
|
&& lptag->wID == ID_MAGIC
|
|
&& lptag->wItem == (int)0xFFFF
|
|
&& lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4)
|
|
&& *(PLONG)lptag->rgb == TAG_MAGIC)
|
|
{
|
|
while ((cb = (DWORD)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg)
|
|
{
|
|
if (lptag->wID == ID_LASTTAG)
|
|
return cb;
|
|
(LPSTR)lptag += lptag->cb;
|
|
}
|
|
}
|
|
return lpgd->cbGroup;
|
|
}
|
|
|
|
|
|
|
|
/* SizeofGroup() - for ansi groups */
|
|
|
|
|
|
DWORD SizeofGroup(LPGROUPDEF lpgd)
|
|
{
|
|
LPPMTAG lptag;
|
|
WORD cbSeg;
|
|
WORD cb;
|
|
|
|
cbSeg = (WORD)GlobalSize(lpgd);
|
|
|
|
lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);
|
|
|
|
if ((WORD)((PCHAR)lptag - (PCHAR)lpgd +MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))+4) <= cbSeg
|
|
&& lptag->wID == ID_MAGIC
|
|
&& lptag->wItem == (int)0xFFFF
|
|
&& lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4)
|
|
&& *(PLONG)lptag->rgb == TAG_MAGIC) {
|
|
|
|
while ((cb = (WORD)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg) {
|
|
if (lptag->wID == ID_LASTTAG)
|
|
return (DWORD)cb;
|
|
(LPSTR)lptag += lptag->cb;
|
|
}
|
|
}
|
|
return lpgd->cbGroup;
|
|
}
|
|
|
|
|
|
|
|
/* IsGroup() - */
|
|
|
|
|
|
BOOL PASCAL IsGroup(PSTR p)
|
|
{
|
|
if (_strnicmp(p, "GROUP", CCHGROUP) != 0) {;
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Can't have 0 for first digit
|
|
*/
|
|
if (p[5] == '0') {
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Everything else must be a number
|
|
*/
|
|
for (p += CCHGROUP; *p; p++) {
|
|
if (*p < '0' || *p > '9') {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* RemoveString() - */
|
|
|
|
|
|
VOID APIENTRY RemoveString(PSTR pString)
|
|
{
|
|
|
|
PSTR pT = pString + lstrlen(pString) + 1;
|
|
|
|
while (*pT)
|
|
{
|
|
while (*pString++ = *pT++)
|
|
;
|
|
}
|
|
*pString = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* StringToEnd() - */
|
|
|
|
|
|
VOID APIENTRY StringToEnd(PSTR pString)
|
|
{
|
|
char *pT,*pTT;
|
|
|
|
for (pT = pString; *pT; )
|
|
while (*pT++)
|
|
;
|
|
for (pTT = pString; *pT++ = *pTT++;)
|
|
;
|
|
*pT = 0;
|
|
|
|
RemoveString(pString);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* GetGroupList() - */
|
|
|
|
|
|
VOID PASCAL GetGroupList(PSTR szList)
|
|
{
|
|
char szT[20];
|
|
PSTR pT, pTT, pS;
|
|
INT cGroups; // The number of Groups= lines.
|
|
|
|
GetPrivateProfileString(szGroups, NULL, szNULL, szList, (CGROUPSMAX+1)*8, szINIFile);
|
|
|
|
cGroups = 0;
|
|
|
|
/*
|
|
* Filter out anything that isn't group#.
|
|
*/
|
|
for (pT = szList; *pT; ) {
|
|
AnsiUpper(pT);
|
|
|
|
if (IsGroup(pT)) {
|
|
pT += lstrlen(pT) + 1;
|
|
cGroups++;
|
|
} else {
|
|
RemoveString(pT);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sort the groups
|
|
*/
|
|
lstrcpy(szT, "Group");
|
|
for (pT = szGroupsOrder; *pT; ) {
|
|
while (*pT == ' ') {
|
|
pT++;
|
|
}
|
|
|
|
if (*pT < '0' || *pT > '9') {
|
|
break;
|
|
}
|
|
|
|
pTT = szT + CCHGROUP;
|
|
while (*pT >= '0' && *pT <= '9') {
|
|
*pTT++ = *pT++;
|
|
}
|
|
*pTT=0;
|
|
|
|
for (pS = szList; *pS; pS += lstrlen(pS) + 1) {
|
|
if (!lstrcmpi(pS,szT)) {
|
|
StringToEnd(pS);
|
|
cGroups--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Move any remaining groups to the end of the list so that they load
|
|
* last and appear on top of everything else - keeps DOS based install
|
|
* programs happy.
|
|
*/
|
|
while (cGroups>0) {
|
|
StringToEnd(szList);
|
|
cGroups--;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CreateGroupHandle() - */
|
|
|
|
/* Creates a discarded handle for use as a group handle... on the first */
|
|
/* LockGroup() the file will be loaded. */
|
|
|
|
|
|
|
|
HANDLE PASCAL CreateGroupHandle(void)
|
|
{
|
|
HANDLE hGroup;
|
|
|
|
if (hGroup = GlobalAlloc(GMEM_MOVEABLE | GMEM_DISCARDABLE, 1L))
|
|
GlobalDiscard(hGroup);
|
|
|
|
return(hGroup);
|
|
}
|
|
|
|
|
|
|
|
/* LockGroup() - */
|
|
|
|
|
|
LPGROUPDEF PASCAL LockGroup(PGROUP pGroup)
|
|
|
|
{
|
|
LPGROUPDEF lpgd;
|
|
int cbGroup;
|
|
int fh;
|
|
PSTR psz;
|
|
|
|
psz = pGroup->lpKey;
|
|
|
|
/* Find and open the group file. */
|
|
fh = _open(pGroup->lpKey, O_RDONLY | O_BINARY);
|
|
if (fh == -1) {
|
|
goto LGError1;
|
|
}
|
|
|
|
/* Find the size of the file by seeking to the end. */
|
|
cbGroup = (WORD)_lseek(fh, 0L, SEEK_END);
|
|
if (cbGroup < sizeof(GROUPDEF)) {
|
|
goto LGError2;
|
|
}
|
|
|
|
_lseek(fh, 0L, SEEK_SET);
|
|
|
|
/* Allocate some memory for the thing. */
|
|
if (!(pGroup->hGroup = GlobalReAlloc(pGroup->hGroup, (DWORD)cbGroup, GMEM_MOVEABLE))) {
|
|
psz = NULL;
|
|
goto LGError2;
|
|
}
|
|
|
|
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
|
|
|
|
/* Read the whole group file into memory. */
|
|
if (_read(fh, (PSTR)lpgd, cbGroup) != cbGroup)
|
|
goto LGError3;
|
|
|
|
if (lpgd->dwMagic == GROUP_MAGIC) {
|
|
/* Validate the group file by checking the magic bytes and the checksum. */
|
|
if (lpgd->cbGroup > (WORD)cbGroup)
|
|
goto LGError3;
|
|
}
|
|
else if (lpgd->dwMagic == GROUP_UNICODE) {
|
|
LPGROUPDEF_U lpgd_U;
|
|
|
|
lpgd_U = (LPGROUPDEF_U)lpgd;
|
|
if (lpgd_U->cbGroup > (DWORD)cbGroup) {
|
|
goto LGError3;
|
|
}
|
|
}
|
|
else {
|
|
goto LGError3;
|
|
}
|
|
|
|
/* Now return the pointer. */
|
|
_close(fh);
|
|
return(lpgd);
|
|
|
|
LGError3:
|
|
GlobalUnlock(pGroup->hGroup);
|
|
GlobalDiscard(pGroup->hGroup);
|
|
|
|
LGError2:
|
|
_close(fh);
|
|
|
|
LGError1:
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* UnlockGroup() - */
|
|
|
|
|
|
void PASCAL UnlockGroup(PGROUP pGroup)
|
|
{
|
|
GlobalUnlock(pGroup->hGroup);
|
|
}
|
|
|
|
|
|
|
|
/* FindFreeIndex() - */
|
|
|
|
|
|
WORD FindFreeIndex(BOOL bCommonGrp)
|
|
{
|
|
WORD wIndex;
|
|
LPSTR pszT;
|
|
WORD i;
|
|
static BOOL bFirstTime = TRUE;
|
|
DWORD cbData;
|
|
|
|
if (!*szGroupsOrder) {
|
|
cbData = sizeof(szGroupsOrder);
|
|
if (RegQueryValueEx(hkeyPMSettings, szOrder, 0, 0, szGroupsOrder, &cbData))
|
|
if (!GetPrivateProfileString(szSettings, szOrder, szNULL, szGroupsOrder, sizeof(szGroupsOrder), szINIFile)) {
|
|
pGroupIndexes[1] = 1;
|
|
return(1);
|
|
}
|
|
}
|
|
|
|
if (bFirstTime) {
|
|
bFirstTime = FALSE;
|
|
|
|
/* Initialize the array to zero since we are 1 based */
|
|
for (i = 1; i <= CGROUPSMAX; i++) {
|
|
pGroupIndexes[i] = 0;
|
|
}
|
|
|
|
pszT = szGroupsOrder;
|
|
while(*pszT) {
|
|
|
|
/* Skip blanks */
|
|
while (*pszT == ' ')
|
|
pszT++;
|
|
|
|
/* Check for NULL */
|
|
if (!(*pszT))
|
|
break;
|
|
|
|
if ( (bCommonGrp && *pszT == 'C') ||
|
|
(!bCommonGrp && *pszT != 'C') ) {
|
|
|
|
if (bCommonGrp)
|
|
pszT++;
|
|
|
|
wIndex = 0;
|
|
|
|
for (; *pszT && *pszT!=' '; pszT++) {
|
|
wIndex *= 10;
|
|
wIndex += *pszT - '0';
|
|
}
|
|
pGroupIndexes[wIndex] = wIndex;
|
|
|
|
} else {
|
|
/* Skip to next entry */
|
|
while (*pszT && *pszT != ' ')
|
|
pszT++;
|
|
}
|
|
}
|
|
}
|
|
for (i = 1; i <= CGROUPSMAX; i++) {
|
|
if (pGroupIndexes[i] != i) {
|
|
pGroupIndexes[i] = i;
|
|
return(i);
|
|
}
|
|
}
|
|
|
|
if (i > CGROUPSMAX) { // too many groups
|
|
return((WORD)-1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* RemoveBackslashFromKeyName() - */
|
|
|
|
/* replace the invalid characters for a key name by some valid charater. */
|
|
/* the same characters that are invalid for a file name are invalid for a */
|
|
/* key name. */
|
|
|
|
|
|
|
|
void RemoveBackslashFromKeyName(LPSTR lpKeyName)
|
|
{
|
|
LPSTR lpt;
|
|
|
|
for (lpt = lpKeyName; *lpt; lpt++) {
|
|
if ((*lpt == '\\') || (*lpt == ':') || (*lpt == '>') || (*lpt == '<') ||
|
|
(*lpt == '*') || (*lpt == '?') ){
|
|
*lpt = '.';
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/* LoadGroup() - */
|
|
|
|
|
|
|
|
PGROUP PASCAL LoadGroup(PSTR pGroupFile, WORD wIndex, BOOL bCommonGrp)
|
|
{
|
|
PGROUP pGroup;
|
|
LPGROUPDEF lpgd;
|
|
char szFmt[] = " %d";
|
|
char szCFmt[] = " C%d";
|
|
char szIndex[5];
|
|
BOOL bNewOrder = FALSE;
|
|
|
|
if (!wIndex) {
|
|
wIndex = FindFreeIndex(bCommonGrp);
|
|
bNewOrder = TRUE;
|
|
}
|
|
|
|
pGroup = (PGROUP)LocalAlloc(LPTR,sizeof(GROUP));
|
|
if (!pGroup) {
|
|
return NULL;
|
|
}
|
|
|
|
pGroup->hGroup = CreateGroupHandle();
|
|
pGroup->pItems = NULL;
|
|
pGroup->hbm = NULL;
|
|
pGroup->wIndex = wIndex;
|
|
|
|
pGroup->lpKey = (PSTR)LocalAlloc(LPTR, lstrlen(pGroupFile) + 1);
|
|
pGroup->fLoaded = FALSE;
|
|
|
|
if (!pGroup->lpKey) {
|
|
GlobalFree(pGroup->hGroup);
|
|
LocalFree((HANDLE)pGroup);
|
|
return NULL;
|
|
}
|
|
|
|
lstrcpy(pGroup->lpKey, pGroupFile);
|
|
|
|
/*
|
|
* Note that we're about to load a group for the first time.
|
|
* NB Stting this tells LockGroup that the caller can handle the errors.
|
|
*/
|
|
lpgd = LockGroup(pGroup);
|
|
|
|
/*
|
|
* The group has been loaded or at least we tried.
|
|
*/
|
|
if (!lpgd) {
|
|
LoadFail:
|
|
LocalFree((HANDLE)pGroup->lpKey);
|
|
GlobalFree(pGroup->hGroup);
|
|
LocalFree((HANDLE)pGroup);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* test if it is a Windows 3.1 group file format. If so it is not
|
|
* valid in WIN32. In Windows 3.1 RECT and POINT are WORD instead of LONG.
|
|
*/
|
|
|
|
if ( lpgd->dwMagic == GROUP_MAGIC &&
|
|
((lpgd->rcNormal.left != (INT)(SHORT)lpgd->rcNormal.left) ||
|
|
(lpgd->rcNormal.right != (INT)(SHORT)lpgd->rcNormal.right) ||
|
|
(lpgd->rcNormal.top != (INT)(SHORT)lpgd->rcNormal.top) ||
|
|
(lpgd->rcNormal.bottom != (INT)(SHORT)lpgd->rcNormal.bottom) )){
|
|
/* The group file is invalid. */
|
|
UnlockGroup(pGroup);
|
|
goto LoadFail;
|
|
}
|
|
|
|
/*
|
|
* In the registry, the group's key is it's title.
|
|
*/
|
|
if (lpgd->dwMagic == GROUP_MAGIC) {
|
|
LocalFree(pGroup->lpKey);
|
|
if (pGroup->lpKey = (PSTR)LocalAlloc(LPTR, lstrlen(PTR(lpgd, lpgd->pName)) + 1))
|
|
lstrcpy(pGroup->lpKey, PTR(lpgd, lpgd->pName));
|
|
RemoveBackslashFromKeyName(pGroup->lpKey);
|
|
}
|
|
else if (lpgd->dwMagic == GROUP_UNICODE){
|
|
LPGROUPDEF_U lpgd_U;
|
|
ANSI_STRING AnsiString;
|
|
UNICODE_STRING UniString;
|
|
|
|
lpgd_U = (LPGROUPDEF_U)lpgd;
|
|
|
|
RtlInitUnicodeString(&UniString, (LPWSTR)(PTR(lpgd_U, lpgd_U->pName)));
|
|
RtlUnicodeStringToAnsiString(&AnsiString, &UniString, TRUE);
|
|
|
|
LocalFree(pGroup->lpKey);
|
|
if (pGroup->lpKey = (PSTR)LocalAlloc(LPTR, lstrlen(AnsiString.Buffer) + 1))
|
|
lstrcpy(pGroup->lpKey, AnsiString.Buffer);
|
|
RemoveBackslashFromKeyName(pGroup->lpKey);
|
|
RtlFreeAnsiString(&AnsiString);
|
|
}
|
|
|
|
UnlockGroup(pGroup);
|
|
|
|
if (bNewOrder) {
|
|
if (bCommonGrp)
|
|
wsprintf(szIndex, szCFmt, wIndex);
|
|
else
|
|
wsprintf(szIndex, szFmt, wIndex);
|
|
lstrcat(szGroupsOrder, szIndex);
|
|
RegSetValueEx(hkeyPMSettings, szOrder, 0, REG_SZ, szGroupsOrder, lstrlen(szGroupsOrder)+1);
|
|
}
|
|
|
|
return(pGroup);
|
|
}
|
|
|
|
|
|
/* UnloadGroup() - */
|
|
void PASCAL UnloadGroup(PGROUP pGroup)
|
|
{
|
|
PITEM pItem, pItemNext;
|
|
|
|
// Free the group segment.
|
|
GlobalFree(pGroup->hGroup);
|
|
|
|
// Free the local stuff.
|
|
LocalFree((HANDLE)pGroup->lpKey);
|
|
|
|
// The item data.
|
|
for (pItem = pGroup->pItems; pItem; pItem = pItemNext) {
|
|
pItemNext = pItem->pNext;
|
|
LocalFree((HANDLE) pItem);
|
|
}
|
|
|
|
// Lastly, free the group structure itself.
|
|
LocalFree((HANDLE)pGroup);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* LoadAllGroups() - */
|
|
|
|
|
|
VOID PASCAL LoadAllGroups()
|
|
{
|
|
PSTR pT, pszT;
|
|
char szGroupList[(CGROUPSMAX+1)*8];
|
|
WORD wIndex;
|
|
char szPath[120];
|
|
PGROUP pGroup;
|
|
|
|
pT = szGroupList;
|
|
for (GetGroupList(pT); *pT; pT += (lstrlen(pT) + 1)) {
|
|
if (!GetPrivateProfileString(szGroups, pT, szNULL, szPath, sizeof(szPath), szINIFile)) {
|
|
continue;
|
|
}
|
|
|
|
wIndex = 0;
|
|
for (pszT = pT + CCHGROUP; *pszT; pszT++) {
|
|
wIndex *= 10;
|
|
wIndex += *pszT - '0';
|
|
}
|
|
|
|
pGroup = LoadGroup(szPath, wIndex, FALSE);
|
|
if (pGroup) {
|
|
SaveGroupInRegistry(pGroup, FALSE, FALSE);
|
|
UnloadGroup(pGroup);
|
|
}
|
|
else {
|
|
bNoError = FALSE;
|
|
wsprintf(szMessage, "An error has occurred reading group file %s, no registry update.\n",
|
|
szPath);
|
|
printf(szMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* SaveGroupInRegistry() - */
|
|
|
|
|
|
|
|
BOOL SaveGroupInRegistry(PGROUP pGroup, BOOL bCommonGrp, BOOL bOverwriteGroup)
|
|
{
|
|
LPGROUPDEF lpgd;
|
|
int cb;
|
|
int err;
|
|
char szT[66];
|
|
static char szFmt[] = "Group%d";
|
|
HKEY hkey;
|
|
HKEY hkeyGroups;
|
|
PSECURITY_ATTRIBUTES pSecAttr;
|
|
DWORD dwDisposition;
|
|
HANDLE hEvent;
|
|
|
|
|
|
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
|
|
if (!lpgd)
|
|
return FALSE;
|
|
|
|
if (bCommonGrp) {
|
|
hkeyGroups = hkeyCommonGroups;
|
|
pSecAttr = pCGrpSecAttr;
|
|
}
|
|
else {
|
|
hkeyGroups = hkeyProgramGroups;
|
|
pSecAttr = pPGrpSecAttr;
|
|
}
|
|
|
|
while(1) {
|
|
if (err = RegCreateKeyEx(hkeyGroups, pGroup->lpKey, 0, 0, 0, DELETE | KEY_READ | KEY_WRITE, pSecAttr, &hkey, &dwDisposition)) {
|
|
goto Exit1;
|
|
}
|
|
if (dwDisposition == REG_CREATED_NEW_KEY) {
|
|
break;
|
|
}
|
|
if (dwDisposition == REG_OPENED_EXISTING_KEY) {
|
|
if (!bOverwriteGroup) {
|
|
RegCloseKey(hkey);
|
|
wsprintf(szMessage, "Could not save the group %s in the registry. The group already exists.", pGroup->lpKey);
|
|
printf(szMessage);
|
|
return(FALSE);
|
|
}
|
|
else {
|
|
RegCloseKey(hkey);
|
|
if (RegDeleteKey(hkeyGroups, pGroup->lpKey) != ERROR_SUCCESS) {
|
|
wsprintf(szMessage, "Could not save the group %s in the registry. The group already exists.", pGroup->lpKey);
|
|
printf(szMessage);
|
|
return(FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* update groups section. */
|
|
wsprintf(szT, szFmt, pGroup->wIndex);
|
|
RegSetValueEx(hkeyPMGroups, szT, 0, REG_SZ, (LPBYTE)pGroup->lpKey, lstrlen(pGroup->lpKey)+1);
|
|
|
|
if (lpgd->dwMagic == GROUP_MAGIC) {
|
|
cb = SizeofGroup(lpgd);
|
|
}
|
|
else {
|
|
cb = SizeofGroup_U((LPGROUPDEF_U)lpgd);
|
|
}
|
|
|
|
err = RegSetValueEx(hkey, NULL, 0, REG_BINARY, (LPTSTR)lpgd, cb);
|
|
|
|
hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, "Progman.GroupValueSet");
|
|
if (hEvent) {
|
|
SetEvent(hEvent);
|
|
}
|
|
|
|
RegFlushKey(hkey);
|
|
RegCloseKey(hkey);
|
|
|
|
Exit1:
|
|
GlobalUnlock(pGroup->hGroup);
|
|
|
|
if (err) {
|
|
bNoError = FALSE;
|
|
wsprintf(szMessage, "Could not save the group %s in the registry.", pGroup->lpKey);
|
|
printf(szMessage);
|
|
}
|
|
GlobalDiscard(pGroup->hGroup);
|
|
return(!err);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ReadSettings() - */
|
|
|
|
|
|
BOOL ReadSettings()
|
|
{
|
|
|
|
OFSTRUCT of;
|
|
CHAR szT[MAX_PATH];
|
|
|
|
lstrcpy(szT, ".\\");
|
|
lstrcat(szT, szINIFile);
|
|
if (OpenFile(szT, &of, OF_EXIST) == -1) {
|
|
// set the current directory to the windows directory
|
|
GetWindowsDirectory(szT, MAX_PATH);
|
|
SetCurrentDirectory(szT);
|
|
}
|
|
if (OpenFile(szINIFile, &of, OF_EXIST) == -1) {
|
|
return(FALSE);
|
|
}
|
|
bMinOnRun = GetPrivateProfileInt(szSettings, szMinOnRun, bMinOnRun, szINIFile);
|
|
bAutoArrange = GetPrivateProfileInt(szSettings, szAutoArrange, bAutoArrange, szINIFile);
|
|
bSaveSettings = GetPrivateProfileInt(szSettings, szSaveSettings, bSaveSettings, szINIFile);
|
|
GetPrivateProfileString(szSettings, szWindow, szNULL, szPMWindowSetting, sizeof(szPMWindowSetting), szINIFile);
|
|
GetPrivateProfileString(szSettings, szStartup, szNULL, szStartupGroup, sizeof(szStartupGroup), szINIFile);
|
|
|
|
fNoRun = GetPrivateProfileInt(szRestrict, szNoRun, FALSE, szINIFile);
|
|
fNoClose = GetPrivateProfileInt(szRestrict, szNoClose, FALSE, szINIFile);
|
|
fNoSave = GetPrivateProfileInt(szRestrict, szNoSave, FALSE, szINIFile);
|
|
fNoFileMenu = GetPrivateProfileInt(szRestrict, szNoFileMenu, FALSE, szINIFile);
|
|
dwEditLevel = GetPrivateProfileInt(szRestrict, szEditLevel, (WORD)0, szINIFile);
|
|
|
|
GetPrivateProfileString(szSettings, szOrder, szNULL, szGroupsOrder, sizeof(szGroupsOrder), szINIFile);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
/* SaveSettingsToRegistry() - */
|
|
|
|
|
|
BOOL SaveSettingsToRegistry()
|
|
{
|
|
int err;
|
|
|
|
if (hkeyPMSettings) {
|
|
err = RegSetValueEx(hkeyPMSettings, szWindow, 0, REG_SZ, szPMWindowSetting, lstrlen(szPMWindowSetting)+1);
|
|
err |= RegSetValueEx(hkeyPMSettings, szOrder, 0, REG_SZ, szGroupsOrder, lstrlen(szGroupsOrder)+1);
|
|
if (*szStartupGroup)
|
|
err |= RegSetValueEx(hkeyPMSettings, szStartup, 0, REG_SZ, szStartupGroup, lstrlen(szStartupGroup)+1);
|
|
err |= RegSetValueEx(hkeyPMSettings, szMinOnRun, 0, REG_DWORD, (LPBYTE)&bMinOnRun, sizeof(bMinOnRun));
|
|
err |= RegSetValueEx(hkeyPMSettings, szAutoArrange, 0, REG_DWORD, (LPBYTE)&bAutoArrange, sizeof(bAutoArrange));
|
|
err |= RegSetValueEx(hkeyPMSettings, szSaveSettings, 0, REG_DWORD, (LPBYTE)&bSaveSettings, sizeof(bSaveSettings));
|
|
}
|
|
|
|
if (hkeyPMRestrict) {
|
|
err = RegSetValueEx(hkeyPMRestrict, szNoRun, 0, REG_DWORD, (LPBYTE)&fNoRun, sizeof(fNoRun));
|
|
err |= RegSetValueEx(hkeyPMRestrict, szNoClose, 0, REG_DWORD, (LPBYTE)&fNoClose, sizeof(fNoClose));
|
|
err |= RegSetValueEx(hkeyPMRestrict, szNoSave, 0, REG_DWORD, (LPBYTE)&fNoSave, sizeof(fNoSave));
|
|
err |= RegSetValueEx(hkeyPMRestrict, szNoFileMenu, 0, REG_DWORD, (LPBYTE)&fNoFileMenu, sizeof(fNoFileMenu));
|
|
err |= RegSetValueEx(hkeyPMRestrict, szEditLevel, 0, REG_DWORD, (LPBYTE)&dwEditLevel, sizeof(dwEditLevel));
|
|
}
|
|
|
|
return(!err);
|
|
}
|
|
|
|
BOOL AccessToPersonalGroups()
|
|
{
|
|
|
|
// Initialize security attributes for Personal Groups.
|
|
|
|
pPGrpSecAttr = &PGrpSecAttr;
|
|
if (!InitializeSecurityAttributes(pPGrpSecAttr, FALSE))
|
|
pPGrpSecAttr = NULL;
|
|
|
|
/*
|
|
* Create/Open the registry keys corresponding to progman.ini sections.
|
|
*/
|
|
if (RegCreateKeyEx(HKEY_CURRENT_USER, szProgramManager, 0, szProgramManager, 0, KEY_READ | KEY_WRITE, pPGrpSecAttr, &hkeyProgramManager, NULL)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
RegCreateKeyEx(hkeyProgramManager, szSettings, 0, szProgramManager, 0, KEY_READ | KEY_WRITE, pPGrpSecAttr, &hkeyPMSettings, NULL);
|
|
RegCreateKeyEx(hkeyProgramManager, szRestrict, 0, szProgramManager, 0, KEY_READ, pPGrpSecAttr, &hkeyPMRestrict, NULL);
|
|
RegCreateKeyEx(hkeyProgramManager, szGroups, 0, szProgramManager, 0, KEY_READ | KEY_WRITE, pPGrpSecAttr, &hkeyPMGroups, NULL);
|
|
if (RegCreateKeyEx(HKEY_CURRENT_USER, szProgramGroups, 0, szProgramGroups, 0, KEY_READ | KEY_WRITE, pPGrpSecAttr, &hkeyProgramGroups, NULL) ){
|
|
return(FALSE);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL AccessToCommonGroups()
|
|
{
|
|
|
|
// Initialize security attributes for Common Groups.
|
|
|
|
pCGrpSecAttr = &CGrpSecAttr;
|
|
if (!InitializeSecurityAttributes(pCGrpSecAttr, TRUE)) {
|
|
pCGrpSecAttr = NULL;
|
|
return(FALSE);
|
|
}
|
|
|
|
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szCommonGroups, 0, szProgramGroups, 0, KEY_READ | KEY_WRITE | DELETE, pCGrpSecAttr, &hkeyCommonGroups, NULL) ){
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void Usage()
|
|
{
|
|
printf("\nConverts a Windows NT compatible .GRP file into the Registry for use by\n\
|
|
Windows NT. Note that the .GRP file must have been created using REGTOGRP.\n\
|
|
GRPTOREG will not accept MS-DOS Windows .GRP files.\n\n\
|
|
GRPTOREG [/o] [/c] groupfiles \n\n\
|
|
groupfiles Path to a .GRP file created by REGTOGRP. If more than one file,\n\
|
|
separate by spaces.\n\
|
|
/o If a Program Manager group already exists with the same name as\n\
|
|
groupfile, overwrite it.\n\
|
|
/c Will create a Common group from the groupfile (must have \n\
|
|
administrative privileges), otherwise a personal group is created.\n");
|
|
|
|
}
|
|
|
|
int __cdecl
|
|
main( argc, argv )
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
INT i;
|
|
CHAR *cp;
|
|
LPSTR pGroupFile;
|
|
PGROUP pGroup;
|
|
BOOL bCommonGrp = FALSE;
|
|
BOOL bOverwriteGroup = FALSE;
|
|
|
|
if (argc > 1) { // just update specified groups.
|
|
|
|
for(i = 1; i < argc && (argv[i][0] == '/' || argv[i][0] == '-'); ++i) {
|
|
for(cp = &argv[i][1]; *cp != '\0'; ++cp) {
|
|
switch(*cp) {
|
|
case 'c':
|
|
|
|
// The user wants common groups.
|
|
// First check if the user has permission to create common groups.
|
|
|
|
if (AccessToCommonGroups()) {
|
|
bCommonGrp = TRUE;
|
|
}
|
|
else {
|
|
wsprintf(szMessage, "You do not have write access to Common Groups. No Groups will be created.");
|
|
printf(szMessage);
|
|
goto Exit;
|
|
}
|
|
break;
|
|
case 'o':
|
|
bOverwriteGroup = TRUE;
|
|
break;
|
|
case '?':
|
|
default:
|
|
Usage();
|
|
goto Exit;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bCommonGrp) {
|
|
|
|
// The user wants personal groups.
|
|
// First check if the user has access to the registry to
|
|
// create personal groups in Progman.
|
|
|
|
if (!AccessToPersonalGroups()) {
|
|
wsprintf(szMessage, "You do not have write access to the registry. No updates will take place.");
|
|
printf(szMessage);
|
|
goto Exit;
|
|
}
|
|
|
|
}
|
|
|
|
for (; i < argc; i++) {
|
|
pGroupFile = argv[i];
|
|
pGroup = LoadGroup(pGroupFile, 0, bCommonGrp);
|
|
if (pGroup) {
|
|
SaveGroupInRegistry(pGroup, bCommonGrp, bOverwriteGroup);
|
|
UnloadGroup(pGroup);
|
|
}
|
|
else {
|
|
bNoError = FALSE;
|
|
wsprintf(szMessage, "An error has occurred reading group file %s, no registry update.",
|
|
pGroupFile);
|
|
printf(szMessage);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // update all groups thru progman.ini
|
|
if (hkeyProgramManager) {
|
|
if (!ReadSettings()) {
|
|
bNoError = FALSE;
|
|
wsprintf(szMessage, "The file PROGMAN.INI is not in this directory.");
|
|
printf(szMessage);
|
|
}
|
|
if (bNoError && !SaveSettingsToRegistry()) {
|
|
// wsprintf(szMessage, "An error occured while saving settings to the registry.");
|
|
}
|
|
}
|
|
if (hkeyProgramGroups) {
|
|
bNoError = TRUE;
|
|
LoadAllGroups();
|
|
if (bNoError) {
|
|
wsprintf(szMessage, "Groups were updated successfully to the registry.");
|
|
printf(szMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
|
|
if (hkeyProgramManager) {
|
|
RegFlushKey(hkeyProgramManager);
|
|
if (hkeyPMSettings)
|
|
RegCloseKey(hkeyPMSettings);
|
|
if (hkeyPMRestrict)
|
|
RegCloseKey(hkeyPMRestrict);
|
|
if (hkeyPMGroups)
|
|
RegCloseKey(hkeyPMGroups);
|
|
if (hkeyProgramManager)
|
|
RegCloseKey(hkeyProgramManager);
|
|
}
|
|
|
|
if (hkeyProgramGroups) {
|
|
RegFlushKey(hkeyProgramGroups);
|
|
RegCloseKey(hkeyProgramGroups);
|
|
}
|
|
|
|
if (hkeyCommonGroups) {
|
|
RegFlushKey(hkeyCommonGroups);
|
|
RegCloseKey(hkeyCommonGroups);
|
|
}
|
|
|
|
|
|
|
|
// Free up the security descriptor
|
|
|
|
|
|
if (pPGrpSecAttr) {
|
|
DeleteSecurityDescriptor(pPGrpSecAttr->lpSecurityDescriptor);
|
|
}
|
|
|
|
if (pCGrpSecAttr) {
|
|
DeleteSecurityDescriptor(pCGrpSecAttr->lpSecurityDescriptor);
|
|
}
|
|
return(TRUE);
|
|
}
|