archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/shell/osshell/convgrp/convgrp.c

860 lines
27 KiB
Raw Blame History

/****************************************************************************/
/* */
/* CONVGRP.H - */
/* */
/* Conversion from Win3.1 16 bit .grp file to NT 32bit .grp files for */
/* the Program Manager */
/* */
/* Created: 10-15-92 Johanne Caron */
/* */
/****************************************************************************/
#include "convgrp.h"
#include <shellapi.h>
#include <shlapip.h>
#if DBG
void DbgPrint(char *, ...);
#define KdPrint(_x_) DbgPrint _x_
#else
#define KdPrint(_x_)
#endif
/*--------------------------------------------------------------------------*/
/* */
/* MyDwordAlign() - */
/* */
/*--------------------------------------------------------------------------*/
WORD MyDwordAlign(int wStrLen)
{
return ((WORD)((wStrLen + 3) & ~3));
}
/*--------------------------------------------------------------------------*/
/* */
/* SizeofGroup() - */
/* */
/*--------------------------------------------------------------------------*/
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 == PMTAG_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;
}
/*--------------------------------------------------------------------------*/
/* */
/* AddUpGroupFile() - */
/* */
/* Calculates the group file's checksum. */
/*--------------------------------------------------------------------------*/
WORD AddUpGroupFile(LPGROUPDEF lpgd)
{
LPINT lpW;
LPINT save_lpW;
DWORD wSum = 0;
DWORD cbFile;
cbFile = SizeofGroup(lpgd);
for (save_lpW = lpW = (LPINT)lpgd, cbFile >>= 2; cbFile; cbFile--, lpW++)
wSum += *lpW;
return (WORD)((DWORD_PTR)lpW - (DWORD_PTR)save_lpW);
}
/*--------------------------------------------------------------------------*/
/* */
/* AddThing() - */
/* */
/* in: */
/* hGroup group handle, must not be discardable */
/* lpStuff pointer to data or NULL to init data to zero */
/* cbStuff count of item (may be 0) if lpStuff is a string */
/* */
/* Adds an object to the group segment and returns its offset. Will */
/* reallocate the segment if necessary. */
/* */
/* Handle passed in must not be discardable */
/* */
/* returns: */
/* 0 failure */
/* > 0 offset to thing in the segment */
/* */
/*--------------------------------------------------------------------------*/
WORD AddThing(HANDLE hGroup, LPSTR lpStuff, WORD cbStuff)
{
WORD cb;
LPGROUPDEF lpgd;
WORD offset;
LPSTR lpT;
WORD cbStuffSize;
WORD cbGroupSize;
WORD myOffset;
if (cbStuff == 0xFFFF) {
return 0xFFFF;
}
if (!cbStuff) {
cbStuff = (WORD)(1 + lstrlen(lpStuff));
}
cbStuffSize = (WORD)MyDwordAlign((int)cbStuff);
lpgd = (LPGROUPDEF)GlobalLock(hGroup);
cb = (WORD)SizeofGroup(lpgd);
cbGroupSize = (WORD)MyDwordAlign((int)cb);
offset = lpgd->cbGroup;
myOffset = (WORD)MyDwordAlign((int)offset);
GlobalUnlock(hGroup);
if (!GlobalReAlloc(hGroup,(DWORD)(cbGroupSize + cbStuffSize), GMEM_MOVEABLE))
return 0;
lpgd = (LPGROUPDEF)GlobalLock(hGroup);
/*
* Slide the tags up
*/
memmove((LPSTR)lpgd + myOffset + cbStuffSize, (LPSTR)lpgd + myOffset,
(WORD)(cbGroupSize - myOffset));
lpgd->cbGroup += cbStuffSize;
lpT = (LPSTR)((LPSTR)lpgd + myOffset);
if (lpStuff) {
memmove(lpT, lpStuff, cbStuff);
} else {
/*
* Zero it
*/
while (cbStuffSize--) {
*lpT++ = 0;
}
}
GlobalUnlock(hGroup);
return myOffset;
}
/*--------------------------------------------------------------------------*/
/* */
/* FindTag() - */
/* */
/*--------------------------------------------------------------------------*/
LPPMTAG FindTag(LPGROUPDEF lpgd, int item, WORD id)
{
LPPMTAG lptag;
int cbSeg;
int cb;
cbSeg = (int)GlobalSize(lpgd);
lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);
if ((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)
&& *(LONG FAR *)lptag->rgb == PMTAG_MAGIC) {
while ((cb = (int)((PCHAR)lptag - (PCHAR)lpgd) + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))) <= cbSeg)
{
if ((item == lptag->wItem)
&& (id == 0 || id == lptag->wID)) {
return lptag;
}
if (lptag->wID == ID_LASTTAG)
return NULL;
(LPSTR)lptag += lptag->cb;
}
}
return NULL;
}
/*--------------------------------------------------------------------------*/
/* */
/* AddTag() - */
/* */
/* in: */
/* h group handle, must not be discardable! */
/* */
/* returns: */
/* 0 failure */
/* 1 success */
/*--------------------------------------------------------------------------*/
INT AddTag(HANDLE h, int item, WORD id, LPSTR lpbuf, int cb)
{
LPPMTAG lptag;
WORD fAddFirst;
LPGROUPDEF lpgd;
int cbNew;
int cbMyLen;
LPGROUPDEF lpgdOld;
if (!cb && lpbuf) {
cb = lstrlen(lpbuf) + 1;
}
cbMyLen = MyDwordAlign(cb);
if (!lpbuf) {
cb = 0;
cbMyLen = 0;
}
lpgd = (LPGROUPDEF)GlobalLock(h);
lptag = FindTag(lpgd, (int)0xFFFF, (WORD)ID_LASTTAG);
if (!lptag) {
/*
* In this case, there are no tags at all, and we have to add
* the first tag, the interesting tag, and the last tag
*/
cbNew = 3 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + 4 + cbMyLen;
fAddFirst = TRUE;
lptag = (LPPMTAG)((LPSTR)lpgd + lpgd->cbGroup);
} else {
/*
* In this case, only the interesting tag needs to be added
* but we count in the last because the delta is from lptag
*/
cbNew = 2 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + cbMyLen;
fAddFirst = FALSE;
}
cbNew += (int)((PCHAR)lptag -(PCHAR)lpgd);
lpgdOld = lpgd;
GlobalUnlock(h);
if (!GlobalReAlloc(h, (DWORD)cbNew, GMEM_MOVEABLE)) {
return 0;
}
lpgd = (LPGROUPDEF)GlobalLock(h);
lptag = (LPPMTAG)((LPSTR)lpgd + ((LPSTR)lptag - (LPSTR)lpgdOld));
if (fAddFirst) {
/*
* Add the first tag
*/
lptag->wID = ID_MAGIC;
lptag->wItem = (int)0xFFFF;
*(LONG FAR *)lptag->rgb = PMTAG_MAGIC;
lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + 4);
(LPSTR)lptag += lptag->cb;
}
/*
* Add the tag
*/
lptag->wID = id;
lptag->wItem = item;
lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + cbMyLen);
if (lpbuf) {
memmove(lptag->rgb, lpbuf, (WORD)cb);
}
(LPSTR)lptag += lptag->cb;
/*
* Add the end tag
*/
lptag->wID = ID_LASTTAG;
lptag->wItem = (int)0xFFFF;
lptag->cb = 0;
GlobalUnlock(h);
return 1;
}
/*--------------------------------------------------------------------------*/
/* */
/* AddItemIconResource() - */
/* */
/* Adds the icon resource to the group item. Returns TRUE if the icon */
/* resource was extracted ok and it was added ok. */
/* */
/*--------------------------------------------------------------------------*/
BOOL AddItemIconResource(HANDLE hNewGroup, LPITEMDEF lpid, WORD iItem, LPSTR lpIconPath)
{
LPGROUPDEF lpgd;
LPBYTE lpIconRes = NULL;
HANDLE hIconRes;
HANDLE hModule;
HICON hIcon;
CHAR szIconExe[MAX_PATH];
WORD id;
WORD offset;
DWORD OldErrorMode;
lpid->cbIconRes = 0;
id = lpid->indexIcon;
lstrcpy(szIconExe, lpIconPath);
CharLower(szIconExe);
if (id > 7 && strstr(szIconExe, "progman")) {
//
// There's one more icon in the NT progman.exe than in the Win3.1
// progman.exe and it's inserted at the 8th icon position. So if
// the icon index is 9 in Win3.1 then it will be the 10th icon in
// NT progman.exe, etc
//
id++;
}
hIcon = ExtractAssociatedIcon(hInst, szIconExe, &id);
if (!hIcon) {
goto Failed;
}
DestroyIcon(hIcon);
lpid->idIcon = id;
OldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
if (hModule = LoadLibrary(szIconExe)) {
SetErrorMode(OldErrorMode);
//
// It's a 32bit .exe
//
hIconRes = FindResource(hModule, MAKEINTRESOURCE(id), MAKEINTRESOURCE(RT_ICON));
if (hIconRes) {
lpid->wIconVer = 3; // resource version is windows 3.x
lpid->cbIconRes = (WORD)SizeofResource(hModule, hIconRes);
if (hIconRes = LoadResource(hModule, hIconRes))
lpIconRes = LockResource(hIconRes);
}
}
else {
SetErrorMode(OldErrorMode);
//
// It's a 16bit .exe
//
if (lpid->wIconVer = ExtractIconResInfo(hInst,
szIconExe,
lpid->indexIcon,
&lpid->cbIconRes,
&hIconRes)){
lpIconRes = GlobalLock(hIconRes);
}
}
//
// Add the item's Icon resource.
//
if (!lpid->cbIconRes) {
goto Failed;
}
offset = AddThing(hNewGroup, lpIconRes, lpid->cbIconRes);
GlobalUnlock(hIconRes);
GlobalFree(hIconRes);
lpgd = (LPGROUPDEF)GlobalLock(hNewGroup);
lpid = ITEM(lpgd, iItem);
if (!offset) {
GlobalUnlock(hNewGroup);
KdPrint(("ConvGrp: AddThing lpIconRes failed for item %d \n", iItem));
goto Failed;
}
lpid->pIconRes = offset;
GlobalUnlock(hNewGroup);
return(TRUE);
Failed:
KdPrint(("ConvGrp: AddItemIconResource failed to extract icon for item %d \n", iItem));
return(FALSE);
}
/*--------------------------------------------------------------------------*/
/* */
/* CreateNewGroup() - */
/* */
/* This function creates a new, empty group. */
/* */
/*--------------------------------------------------------------------------*/
HANDLE CreateNewGroup(LPGROUPDEF16 lpGroup16)
{
HANDLE hT;
LPGROUPDEF lpgd;
int i;
int cb;
int cItems; // number of items in 16bit group
LPSTR pGroupName; // 16bit group name
INT wGroupNameLen; //length of pGroupName DWORD aligned.
pGroupName = PTR(lpGroup16, lpGroup16->pName);
wGroupNameLen = MyDwordAlign(lstrlen(pGroupName) + 1);
cItems = lpGroup16->cItems;
cb = sizeof(GROUPDEF) + (cItems * sizeof(WORD)) + wGroupNameLen;
//
// In CreateNewGroup before GlobalAlloc.
//
hT = GlobalAlloc(GHND, (DWORD)cb);
if (!hT) {
return NULL;
}
lpgd = (LPGROUPDEF)GlobalLock(hT);
//
// use the 16bit .grp file settings for what we can.
//
lpgd->nCmdShow = lpGroup16->nCmdShow;
lpgd->wIconFormat = lpGroup16->wIconFormat;
lpgd->cxIcon = lpGroup16->cxIcon;
lpgd->cyIcon = lpGroup16->cyIcon;
lpgd->ptMin.x = (INT)lpGroup16->ptMin.x;
lpgd->ptMin.y = (INT)lpGroup16->ptMin.y;
SetRect(&(lpgd->rcNormal),
(INT)lpGroup16->rcNormal.Left,
(INT)lpGroup16->rcNormal.Top,
(INT)lpGroup16->rcNormal.Right,
(INT)lpGroup16->rcNormal.Bottom);
lpgd->dwMagic = GROUP_MAGIC;
lpgd->wCheckSum = 0; /* adjusted later... */
lpgd->cbGroup = (WORD)cb;
lpgd->pName = sizeof(GROUPDEF) + cItems * sizeof(WORD);
lpgd->cItems = (WORD)cItems;
for (i = 0; i < cItems; i++) {
lpgd->rgiItems[i] = 0;
}
lstrcpy((LPSTR)lpgd + sizeof(GROUPDEF) + cItems * sizeof(WORD),
pGroupName);
lpgd->wCheckSum = -(AddUpGroupFile(lpgd));
GlobalUnlock(hT);
return(hT);
}
/*--------------------------------------------------------------------------*/
/* */
/* Create32bitGroupFormat() - */
/*
/* returns the size of the new 32bit group.
/* */
/*--------------------------------------------------------------------------*/
int Create32bitGroupFormat(LPGROUPDEF16 lpGroup16,
int cbGroup16Size,
LPHANDLE lphNewGroup)
{
HANDLE hNewGroup;
LPGROUPDEF lpgd;
LPITEMDEF lpid;
LPBYTE lpid16;
LPBYTE lptag16;
LPSTR lpTagValue;
WORD wTagId;
LPSTR lpT;
WORD offset;
int cb;
int i;
hNewGroup = CreateNewGroup(lpGroup16);
if (!hNewGroup) {
return(0);
}
//
// Add all items to the new formatted group.
//
for (i = 0; (i < (int)lpGroup16->cItems) && (i < CITEMSMAX); i++) {
//
// Get the pointer to the 16bit item
//
lpid16 = ITEM16(lpGroup16, i);
//
// Create the item.
//
offset = AddThing(hNewGroup, NULL, sizeof(ITEMDEF));
if (!offset) {
KdPrint(("ConvGrp: Addthing ITEMDEF failed for item %d \n", i));
goto QuitThis;
}
lpgd = (LPGROUPDEF)GlobalLock(hNewGroup);
lpgd->rgiItems[i] = offset;
lpid = ITEM(lpgd, i);
//
// Set the item's position.
//
lpid->pt.x = *(LPWORD)lpid16;
lpid->pt.y = *((LPWORD)lpid16 + 1);
//
// Add the item's Name.
//
GlobalUnlock(hNewGroup);
lpT = PTR(lpGroup16, *((LPWORD)lpid16 + 9));
offset = AddThing(hNewGroup, lpT, 0);
if (!offset) {
KdPrint(("ConvGrp: Addthing pName failed for item %d \n", i));
goto PuntCreation;
}
lpgd = (LPGROUPDEF)GlobalLock(hNewGroup);
lpid = ITEM(lpgd, i);
lpid->pName = offset;
//
// Add the item's Command line.
//
GlobalUnlock(hNewGroup);
lpT = PTR(lpGroup16, *((LPWORD)lpid16 + 10));
offset = AddThing(hNewGroup, lpT, 0);
if (!offset) {
KdPrint(("ConvGrp: Addthing pCommand failed for item %d \n", i));
goto PuntCreation;
}
lpgd = (LPGROUPDEF)GlobalLock(hNewGroup);
lpid = ITEM(lpgd, i);
lpid->pCommand = offset;
//
// Add the item's Icon path.
//
GlobalUnlock(hNewGroup);
lpT = PTR(lpGroup16, *((LPWORD)lpid16 + 11));
offset = AddThing(hNewGroup, lpT, 0);
if (!offset) {
KdPrint(("ConvGrp: Addthing pIconPath failed for item %d \n", i));
goto PuntCreation;
}
lpgd = (LPGROUPDEF)GlobalLock(hNewGroup);
lpid = ITEM(lpgd, i);
lpid->pIconPath = offset;
//
// Get the item's icon resource using the Icon path and the icon index.
// And add the item's Icon resource.
//
GlobalUnlock(hNewGroup);
lpid->indexIcon = *((LPWORD)lpid16 + 2);
if (!AddItemIconResource(hNewGroup, lpid, (WORD)i, lpT)) {
KdPrint(("ConvGrp: AddItemIconResource failed for item %d \n", i));
goto PuntCreation;
}
}
/*
* Copy all the tags to the new group format.
*/
lptag16 = (LPSTR)lpGroup16 + lpGroup16->cbGroup;
if (*(UNALIGNED WORD *)lptag16 == ID_MAGIC &&
*((UNALIGNED WORD *)(lptag16+1)) == 0xFFFF &&
*(UNALIGNED DWORD *)((UNALIGNED WORD *)(lptag16+3)) == PMTAG_MAGIC) {
//
// This is the first tag id, goto start of item tags.
//
lptag16 += *((LPWORD)lptag16+2);
while (*(LPWORD)lptag16 != ID_LASTTAG) {
wTagId = *(LPWORD)lptag16;
if (wTagId == ID_MINIMIZE) {
lpTagValue = NULL;
}
else {
lpTagValue = (LPSTR)((LPWORD)lptag16 + 3);
}
if (! AddTag( hNewGroup,
(int)*((LPWORD)lptag16 + 1), // wItem
wTagId, // wID
lpTagValue, // rgb : tag value
*((LPWORD)lptag16 + 2) - (3 * sizeof(WORD)) // cb - sizeof tag
)) {
KdPrint(("ConvGrp: AddTag wItem=%d, wID=%d failed \n",
*((LPWORD)lptag16 + 1),
*(LPWORD)lptag16));
}
lptag16 += *((LPWORD)lptag16 + 2); // go to next tag
}
}
lpgd = GlobalLock(hNewGroup);
cb = SizeofGroup(lpgd);
GlobalUnlock(hNewGroup);
*lphNewGroup = hNewGroup;
return(cb);
PuntCreation:
QuitThis:
if (hNewGroup) {
GlobalFree(hNewGroup);
}
return(0);
}
/*--------------------------------------------------------------------------*/
/* */
/* ReadGroup() - */
/* */
/* Read in the 16bit group file. */
/* */
/*--------------------------------------------------------------------------*/
int ReadGroup(LPSTR pszPath, LPHANDLE lphGroup)
{
HANDLE hGroup;
LPBYTE lpgd;
int cbGroup;
int fh;
PSTR psz;
//
// Find and open the group file.
//
fh = _open(pszPath, O_RDONLY | O_BINARY);
if (fh == -1) {
KdPrint(("ConvGrp: Could NOT open file %s \n", pszPath));
fprintf(stderr, "ConvGrp: Could NOT open file %s \n", pszPath);
goto LGError1;
}
//
// Find the size of the file by seeking to the end.
//
cbGroup = (WORD)_lseek(fh, 0L, SEEK_END);
if (cbGroup < sizeof(GROUPDEF)) {
KdPrint(("ConvGrp: bad group file - %s\n", pszPath));
fprintf(stderr, "ConvGrp: bad group file - %s\n", pszPath);
goto LGError2;
}
_lseek(fh, 0L, SEEK_SET);
//
// Allocate some memory for the thing.
//
if (!(hGroup = GlobalAlloc(GMEM_MOVEABLE|GMEM_DISCARDABLE, (DWORD)cbGroup))) {
KdPrint(("ConvGrp: Alloc failed for input file %s\n", pszPath));
psz = NULL;
goto LGError2;
}
lpgd = (LPBYTE)GlobalLock(hGroup);
//
// Read the whole group file into memory.
//
if (_read(fh, (PSTR)lpgd, cbGroup) != cbGroup) {
fprintf(stderr, "ConvGrp: Could NOT read file %s\n", pszPath);
goto LGError3;
}
//
// Validate the group file by checking the magic bytes and the checksum.
//
if (*((LPWORD)lpgd + 3) > (WORD)cbGroup) {
fprintf(stderr, "ConvGrp: Invalid group file - %s\n", pszPath);
goto LGError3;
}
if (*(LPDWORD)lpgd != GROUP_MAGIC) {
fprintf(stderr, "ConvGrp: Invalid group file - %s\n", pszPath);
goto LGError3;
}
//
// Test if this is an NT .grp file
//
if ( (((LPGROUPDEF)lpgd)->rcNormal.left == (INT)(SHORT)((LPGROUPDEF)lpgd)->rcNormal.left) &&
(((LPGROUPDEF)lpgd)->rcNormal.right == (INT)(SHORT)((LPGROUPDEF)lpgd)->rcNormal.right) &&
(((LPGROUPDEF)lpgd)->rcNormal.top == (INT)(SHORT)((LPGROUPDEF)lpgd)->rcNormal.top) &&
(((LPGROUPDEF)lpgd)->rcNormal.bottom == (INT)(SHORT)((LPGROUPDEF)lpgd)->rcNormal.bottom) ){
//
// it's an NT .grp file, not valid for conversion
//
fprintf(stderr, "ConvGrp: Invalid group file - %s\n", pszPath);
goto LGError3;
}
_close(fh);
GlobalUnlock(hGroup);
*lphGroup = hGroup;
return(cbGroup);
LGError3:
GlobalUnlock(hGroup);
GlobalDiscard(hGroup);
LGError2:
_close(fh);
LGError1:
*lphGroup = NULL;
return(0);
}
#define S_IREAD 0000400 /* read permission, owner */
#define S_IWRITE 0000200 /* write permission, owner */
/*--------------------------------------------------------------------------*/
/* */
/* Write32bitGroup() - */
/* */
/* Write out the 32bit group file. */
/* */
/*--------------------------------------------------------------------------*/
BOOL Write32bitGroup(LPGROUPDEF lpgd, int cbGroup, LPSTR pszPath)
{
int fh;
DWORD Error = 0;
fh = _open(pszPath, O_CREAT | O_WRONLY | O_BINARY, S_IREAD | S_IWRITE);
if (fh == -1) {
Error = GetLastError();
fprintf(stderr, "ConvGrp: Could NOT open output file - %s\n", pszPath);
goto Exit1;
}
if (_write(fh, (PSTR)lpgd, cbGroup) != (int)cbGroup) {
Error = GetLastError();
fprintf(stderr, "ConvGrp: Could NOT write to output file - %s\n", pszPath);
}
_write(fh, NULL, 0); // truncate if getting smaller
_close(fh);
Exit1:
if (Error) {
KdPrint((" Error = %d \n", Error));
}
return (Error == 0);
}
int __cdecl main(
int argc,
char *argv[],
char *envp[])
{
HANDLE h16bitGroup;
HANDLE h32bitGroup;
LPGROUPDEF16 lp16bitGroup;
LPGROUPDEF lp32bitGroup;
LPSTR lp16bitGroupFile;
LPSTR lp32bitGroupFile;
int cbGroup;
BOOL bRet = FALSE;
hInst = GetModuleHandle(NULL);
//
// We need the name of the 16bit .grp file and the name of the
// 32bit .grp file. The first being the 16bit .grp file
if (argc != 3) {
fprintf(stderr, "ConvGrp: Invalid number of paramters, should have 2 filenames\n");
fprintf(stderr, "\nusage: convgrp <Win3.1 .grp filename> <NT .grp filename>\n");
return(FALSE);
}
//
// The first argument is the name of the 16bit group file,
// the second argument is the filename for the 32bit group file.
//
//
lp16bitGroupFile = argv[1];
lp32bitGroupFile = argv[2];
cbGroup = ReadGroup(lp16bitGroupFile, &h16bitGroup);
if (!cbGroup) {
return(FALSE);
}
if (!(lp16bitGroup = (LPGROUPDEF16)GlobalLock(h16bitGroup))) {
KdPrint(("ConvGrp: GlobalLock failed on %s\n", "h16bitGroup"));
goto Exit;;
}
cbGroup = Create32bitGroupFormat(lp16bitGroup, cbGroup, &h32bitGroup);
if (cbGroup) {
lp32bitGroup = (LPGROUPDEF)GlobalLock(h32bitGroup);
bRet = Write32bitGroup(lp32bitGroup, cbGroup, lp32bitGroupFile);
GlobalUnlock(h32bitGroup);
GlobalFree(h32bitGroup);
}
Exit:
if (h16bitGroup) {
GlobalFree(h16bitGroup);
}
if (bRet) {
fprintf(stderr, "ConvGrp: group successfully converted\n");
}
return(bRet);
}