/*************************************************************
This module contains subroutines for nead.c that specifically
deal with the manipulation of EAs.
Procedures in this file:
AddEA() Handles the Add button press
QueryEAs() Reads in all the EAs associated with a file
CheckEAIntegrity() Checks an EA buffer to see if it is valid
Free_FEAList() Deallocates memory associated with EA list
LookupEAType() Gets an offset into table for an EA type
DeleteCurEA() Deletes the highlighted EA
CurEAType() Returns EA Type given a HoldFEA ptr
GetUSHORT() Returns nth USHORT in ->aValue
WriteEAs() Updates EAs state on the disk
EditEAValues() Handles editing a given EA (also m-m EAs)
EAExists() Determines if the given EA Name exists
ChangeName() Handles the change of an EA's name
MultiTypeIndex() Gets a specific field in a m-m structure
EAValueString() Returns a representational string for an EA
MultiAdd() Handles addition of a field for m-m
**************************************************************/
#include "nead.h"
/************ External GLOBALS *******************************/
extern CHAR szFileName[CCHMAXPATH];
extern CHAR szEAName[MAXEANAME+1];
extern USHORT usRetEAType;
extern BOOL FILE_ISOPEN;
extern BOOL FILE_CHANGED;
extern BOOL COMMAND_LINE_FILE;
extern HHEAP hhp;
extern CHAR *pAlloc,*szEditBuf,*szAscii,*szScratch;
extern HOLDFEA *pHoldFEA;
extern DELETELIST *pDelList;
extern EADATA ConvTable[EATABLESIZE];
/*************************************************************/
/*
* Function name: AddEA()
*
* Parameters: hwnd which is the current window handle.
*
* Returns: TRUE iff the EA is successfully added.
*
* Purpose: This routine handles the addition of a new EA to the linked list.
*
* Usage/Warnings: Routine does NOT do full memory error trapping and the
* insert message to the l-box is not error checked.
*
* Calls: EditEAValue()
*/
BOOL AddEA(HWND hwnd)
{
HOLDFEA *pFEA=pHoldFEA; /* Points to the beginning of the EA list */
HOLDFEA *pNewFEA; /* Used to temporarily hold the new EA */
PASSDATA PData;
if(!FILE_ISOPEN)
return(FALSE);
if(!WinDlgBox(HWND_DESKTOP, /* get new EA name and type */
hwnd,
AddEAProc,
(HMODULE)NULL,
IDD_ADDEA,
NULL))
return(FALSE); /* they said cancel */
GetMem(pNewFEA, sizeof(HOLDFEA)); /* Allocate space for new EA struct */
pNewFEA->cbName = (CHAR) strlen(szEAName); /* Fill in new structure */
pNewFEA->cbValue= 0;
pNewFEA->fEA = 0; /* Need bit NOT set */
GetMem(pNewFEA->szName,pNewFEA->cbName+1); /* Name returned in szEAName */
strcpy(pNewFEA->szName,strupr(szEAName));
pNewFEA->aValue = NULL;
pNewFEA->next = NULL;
if(pHoldFEA == NULL) /* It's the first EA for the file */
{
pHoldFEA = pNewFEA;
}
else /* Add EA to the end of the linked list */
{
while(pFEA->next)
pFEA = pFEA->next;
pFEA->next = pNewFEA;
}
PData.Point = (CHAR *) pNewFEA; /* Setup user data for call */
PData.cbMulti = 0; /* to edit of the name and */
PData.usMultiOffset = 0; /* EA Value */
if(!EditEAValue(hwnd,&PData)) /* They canceled the edit */
{
if(pFEA) /* It's not the only EA */
pFEA->next = NULL; /* Disconnect the partial new EA */
else
pHoldFEA = NULL; /* The new EA was the first one */
FreeMem(pNewFEA->szName,pNewFEA->cbName+1);
FreeMem(pNewFEA,sizeof(HOLDFEA));
return(FALSE);
}
WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_INSERTITEM, /* Insert name in L-Box */
MPFROM2SHORT(LIT_END,0),
MPFROMP(pNewFEA->szName));
return(TRUE);
}
/*
* Function name: QueryEAs()
*
* Parameters: hwnd which is the current window handle.
* pszPath points to the path of the file to grab EAs from.
*
* Returns: TRUE iff it successfully reads in the EAs. Upon exit, global
* pHoldFEA points to a linked list of the EAs for the current file.
*
* Purpose: Call DOS to Query a file's EA names and values.
*
* Usage/Warnings: Routine does NOT do full memory error trapping.
* NOTE: This routine does NOT prevent other processes
* from accessing the file's EAs while it is reading them
* in, or while the program is editing them.
*
* Calls: Free_FEAList(), CheckEAIntegrity()
*/
BOOL QueryEAs(HWND hwnd,CHAR *pszPath)
{
CHAR *pAlloc; /* Holds the FEA struct returned by DosEnumAttribute */
/* also used to create the GEALIST for DosQPathInfo */
CHAR *pBigAlloc; /* Temp buffer to hold each EA as it is read in */
USHORT cbBigAlloc; /* Size of buffer */
ULONG ulEntryNum = 1; /* count of current EA to read (1-relative) */
ULONG ulEnumCnt; /* Number of EAs for Enum to return, always 1 */
HOLDFEA *pLastIn; /* Points to last EA added, so new EA can link */
HOLDFEA *pNewFEA; /* Struct to build the new EA in */
FEA *pFEA; /* Used to read from Enum's return buffer */
GEALIST *pGEAList; /* Ptr used to set up buffer for DosQPathInfo call */
EAOP eaopGet; /* Used to call DosQPathInfo */
GetMem((HHEAP) pAlloc,(USHORT) MAX_GEA); /* Allocate enough room for any GEA List */
pFEA = (FEA *) pAlloc; /* pFEA always uses pAlloc buffer */
pHoldFEA = NULL; /* Reset the pointer for the EA linked list */
while(TRUE) /* Loop continues until there are no more EAs */
{
ulEnumCnt = 1; /* Only want to get one EA at a time */
if(DosEnumAttribute(Ref_ASCIIZ, /* Read into pAlloc Buffer */
pszPath, /* Note that this does not */
ulEntryNum, /* get the aValue field, */
pAlloc, /* so DosQPathInfo must be */
MAX_GEA, /* called to get it. */
&ulEnumCnt,
(LONG) GetInfoLevel1,
0L))
break; /* There was some sort of error */
if(ulEnumCnt != 1) /* All the EAs have been read */
break;
ulEntryNum++;
GetMem(pNewFEA,sizeof(HOLDFEA));
if (pNewFEA == NULL) /* Out of memory */
{
FreeMem(pAlloc,MAX_GEA);
Free_FEAList(pHoldFEA,pDelList);
return (FALSE);
}
pNewFEA->cbName = pFEA->cbName; /* Fill in the HoldFEA structure */
pNewFEA->cbValue= pFEA->cbValue;
pNewFEA->fEA = pFEA->fEA;
pNewFEA->next = NULL;
GetMem(pNewFEA->szName,pFEA->cbName +1); /* Allocate for 2 arrays */
GetMem(pNewFEA->aValue,pFEA->cbValue);
if (!pNewFEA->szName || !pNewFEA->aValue) /* Out of memory */
{
if(pNewFEA->szName)
FreeMem(pNewFEA->szName,pFEA->cbName+1);
if(pNewFEA->aValue)
FreeMem(pNewFEA->aValue,pFEA->cbValue);
FreeMem(pAlloc, MAX_GEA);
FreeMem(pNewFEA,sizeof(HOLDFEA));
Free_FEAList(pHoldFEA,pDelList);
return (FALSE);
}
strcpy(pNewFEA->szName,pAlloc+sizeof(FEA)); /* Copy in EA Name */
cbBigAlloc = sizeof(FEALIST) + pNewFEA->cbName+1 + pNewFEA->cbValue;
GetMem(pBigAlloc,cbBigAlloc);
if (pBigAlloc == NULL)
{
FreeMem(pNewFEA->szName,pFEA->cbName+1);
FreeMem(pNewFEA->aValue,pFEA->cbValue);
FreeMem(pAlloc, MAX_GEA);
FreeMem(pNewFEA,sizeof(HOLDFEA));
Free_FEAList(pHoldFEA,pDelList);
return (FALSE);
}
pGEAList = (GEALIST *) pAlloc; /* Set up GEAList structure */
pGEAList->cbList = sizeof(GEALIST) + pNewFEA->cbName; /* +1 for NULL */
pGEAList->list[0].cbName = pNewFEA->cbName;
strcpy(pGEAList->list[0].szName,pNewFEA->szName);
eaopGet.fpGEAList = (GEALIST far *) pAlloc;
eaopGet.fpFEAList = (FEALIST far *) pBigAlloc;
eaopGet.fpFEAList->cbList = cbBigAlloc;
DosQPathInfo(pszPath, /* Get the complete EA info */
GetInfoLevel3,
(PVOID) &eaopGet,
sizeof(EAOP),
0L);
memcpy(pNewFEA->aValue, /* Copy the value to HoldFEA */
pBigAlloc+sizeof(FEALIST)+pNewFEA->cbName+1,
pNewFEA->cbValue);
FreeMem(pBigAlloc,cbBigAlloc); /* Release the temp Enum buffer */
if(!CheckEAIntegrity(pNewFEA->aValue,pNewFEA->cbValue)) /* Bad EA */
{
FreeMem(pNewFEA->szName,pFEA->cbName+1);
FreeMem(pNewFEA->aValue,pFEA->cbValue);
FreeMem(pNewFEA,sizeof(HOLDFEA));
continue; /* Don't add this EA to linked list */
}
if(pHoldFEA == NULL) /* If first EA, set pHoldFEA */
pHoldFEA = pNewFEA;
else /* Otherwise, add to end of list */
pLastIn->next = pNewFEA;
pLastIn = pNewFEA; /* Update the end of the list */
}
FreeMem(pAlloc, MAX_GEA); /* Free up the GEA buf for DosEnum */
return (TRUE);
}
/*
* Function name: CheckEAIntegrity()
*
* Parameters: aBuf points to the buffer to check for a valid EA.
* cbBuf is the allocated length of aBuf.
*
* Returns: TRUE iff the buffer is a valid EA structure.
*
* Purpose: This routine checks the integrity of the passed EA buffer by
* seeing if there are any non-standard EA types, or bad data that
* isn't sized correctly.
*
* Usage/Warnings: Routine uses MultiTypeIndex() to check m-m type EAs
* since they are potentially recursive. However, this
* may not be a good idea if the m-m EA is severly
* corrupted because it may cause MTI() to attempt a read
* from protected memory. Routine does NOT modify the
* buffer under any circumstance.
*
* Calls: MultiTypeIndex()
*/
BOOL CheckEAIntegrity(CHAR *aBuf,USHORT cbBuf)
{
USHORT *pusPtr = (USHORT *) aBuf;
USHORT usOffset;
CHAR *aEndPtr;
usOffset = LookupEAType(*pusPtr); /* Get the EA type */
switch(ConvTable[usOffset].usFldType)
{
case IDD_LPDATA:
pusPtr++;
if(*pusPtr + 2*sizeof(USHORT) == cbBuf)
return TRUE;
else
return FALSE;
case IDD_MULTILIST:
if(*pusPtr == EA_MVMT)
{
pusPtr += 2;
/* This checks where the end of the m-m list ends to determine
the size of the EA. This is probably not good if the EA is
badly corrupted and it points to protected memory */
aEndPtr = MultiTypeIndex(aBuf,*pusPtr);
if(aEndPtr - aBuf == (SHORT) cbBuf)
return TRUE;
else
return FALSE;
}
else /* Single type, multi-value is not yet implemented */
{
return TRUE;
}
default:
return FALSE;
}
return TRUE;
}
/*
* Function name: Free_FEAList()
*
* Parameters: pFEA points to the beginning of the linked list to be freed.
* pDList points to the beginning of the deleted linked list.
*
* Returns: VOID. The two linked lists passed in are cleaned out though.
*
* Purpose: This routine frees up the current list of EAs by deallocating
* the space used by the szName and aValue fields, then deallocating
* the HoldFEA struct. Next, it deletes the EAName space, then the
* DeleteList structure.
*
* Usage/Warnings: Note that NEAD always passes in pHoldFEA and pDelList
* which is unnecessary since they are global pointers;
* however, this is done to make the routine more flexible
* by allowing multiple linked lists to exist.
*
* Calls:
*/
VOID Free_FEAList(HOLDFEA *pFEA,DELETELIST *pDList)
{
HOLDFEA *next; /* Holds the next field since we free the structure */
/* before reading the current next field */
DELETELIST *Dnext; /* Same purpose as *next */
while(pFEA)
{
next = pFEA->next;
if(pFEA->szName) /* Free if non-NULL name */
FreeMem(pFEA->szName,pFEA->cbName+1);
if(pFEA->aValue) /* Free if non-NULL value */
FreeMem(pFEA->aValue,pFEA->cbValue);
FreeMem(pFEA,sizeof(HOLDFEA)); /* Free HoldFEA struct */
pFEA = next;
}
while(pDList)
{
Dnext = pDList->next;
if(pDList->EAName)
FreeMem(pDList->EAName,strlen(pDList->EAName)+1);
FreeMem(pDList,sizeof(DELETELIST));
pDList = Dnext;
}
}
/*
* Function name: LookupEAType()
*
* Parameters: usType is tye EA type to be looked up.
*
* Returns: An offset into the ConvTable to the appropriate entry. If no
* match is found, the return value points to the last entry,
* non-conventional format.
*
* Purpose: This routine takes EA type and returns an offset into ConvTable
* which points to an entry that describes the type passed in.
*
* Usage/Warnings:
*
* Calls:
*/
USHORT LookupEAType(USHORT usType)
{
USHORT cnt;
for(cnt=0;cnt<EATABLESIZE-1;cnt++)
if(ConvTable[cnt].usPrefix == usType)
return(cnt);
return(cnt);
}
/*
* Function name: DeleteCurEA()
*
* Parameters: hwnd is the current window handle.
*
* Returns: VOID. Removes one item from global pHoldFEA list and adds one
* to global pDelList.
*
* Purpose: This routine removes in memory the currently highlighted EA from
* the EA list. It places the deleted EA in the global pDelList
* linked list.
*
* Usage/Warnings: The memory allocation routines are NOT fully error trapped.
*
* Calls: GetCurFEA()
*/
VOID DeleteCurEA(HWND hwnd)
{
HOLDFEA *pFEA,*pFEAPrev;
DELETELIST *pDL,*pDLcnt; /* Utility ptrs for manipulating the Del list */
LONG lOffset;
pFEA = GetCurFEA(hwnd,pHoldFEA); /* Gets a pointer to item to delete */
if (pFEA == NULL)
return;
/* These two allocations should be checked for out of memory */
GetMem(pDL,sizeof(DELETELIST)); /* Add Name to Delete List */
GetMem(pDL->EAName,pFEA->cbName+1);
strcpy(pDL->EAName,pFEA->szName);
pDL->next = NULL;
if(pDelList == NULL) /* The del list was previously empty */
pDelList = pDL;
else /* tack name onto the end of the list */
{
pDLcnt = pDelList;
while(pDLcnt->next)
pDLcnt = pDLcnt->next;
pDLcnt->next = pDL;
}
lOffset = (LONG) WinSendDlgItemMsg(hwnd, IDD_LBOX,
LM_QUERYSELECTION,0,0);
WinSendDlgItemMsg(hwnd, IDD_LBOX,
LM_DELETEITEM,MPFROMSHORT((SHORT) lOffset),0L);
if(lOffset<1) /* Remove pFEA from the linked list */
{
pHoldFEA = pFEA->next;
}
else
{
pFEAPrev = pHoldFEA;
while(--lOffset) /* Find previous EA */
pFEAPrev = pFEAPrev->next;
pFEAPrev->next = pFEA->next;
}
FreeMem(pFEA->szName,pFEA->cbName+1); /* Release the memory */
FreeMem(pFEA->aValue,pFEA->cbValue);
FreeMem(pFEA,sizeof(HOLDFEA));
FILE_CHANGED = TRUE;
}
/*
* Function name: CurEAType()
*
* Parameters: pFEA points to the FEA struct to use.
*
* Returns: The EA type.
*
* Purpose: Given an EA structure, this routine returns the Type of the EA
* which resides in the first USHORT of the aValue member.
* This function is the same as GetUSHORT(pFEA,0)
*
* Usage/Warnings: Assumes a valid HoldFEA struct.
*
* Calls:
*/
USHORT CurEAType(HOLDFEA *pFEA) /* Same as GetUSHORT(,0); */
{
USHORT *pusType; /* EA Type is stored in first USHORT of aValue field */
pusType = (USHORT *) pFEA->aValue;
return(*pusType);
}
/*
* Function name: GetUSHORT()
*
* Parameters: pFEA points to the FEA struct to use.
* index is an offset of the USHORT to be returned
*
* Returns: The appropriate USHORT from the aValue field
*
* Purpose: This routine returns the nth USHORT value in the aValue member
* of pFEA using index as the offset.
*
* Usage/Warnings: Assumes a valid HoldFEA struct and that index doesn't
* point outside the aValue buffer.
*
* Calls:
*/
USHORT GetUSHORT(HOLDFEA *pFEA,USHORT index)
{
USHORT *pusType;
pusType = (USHORT *) pFEA->aValue;
while(index-- > 0)
pusType++;
return(*pusType);
}
/*
* Function name: WriteEAs()
*
* Parameters: hwnd is the current window handle used only by memory
* allocation error handling.
*
* Returns: VOID. But cleans out the pDelList linked list.
*
* Purpose: This routine updates the EAs on disk to reflect their current
* condition in memory. First, all EAs in the delete list are
* removed from the disk, then all EAs in the pHoldFEA list are
* written out to disk.
*
* Usage/Warnings: NOTE: This routine is not bulletproof as it does not get
* exclusive access to the file EAs, nor does it handle out
* of disk space sort of errors. Also, memory fetches are
* not fully error trapped.
*
* Calls:
*/
VOID WriteEAs(HWND hwnd)
{
DELETELIST *pDL = pDelList,*pDLnext;
HOLDFEA *pHFEA= pHoldFEA;
EAOP eaopWrite;
CHAR aBuf[MAX_GEA],*aPtr;
FEA *pFEA = (FEA *) &aBuf[sizeof(ULONG)];
USHORT usRet,usMemNeeded;
ULONG *pulPtr=(ULONG *) aBuf; /* Initally points to top of FEALIST */
if(!FILE_ISOPEN || !FILE_CHANGED) /* Don't write unless it's necessary */
return;
eaopWrite.fpFEAList = (FEALIST far *) aBuf; /* Setup fields that won't */
pFEA->fEA = 0; /* change for the delete */
pFEA->cbValue = 0; /* calls to DosSetPathInfo */
while(pDL) /* Clean out all the deleted EA names */
{
pFEA->cbName = (UCHAR) strlen(pDL->EAName);
*pulPtr = sizeof(FEALIST) + pFEA->cbName+1; /* +1 for NULL */
strcpy(aBuf+sizeof(FEALIST),pDL->EAName);
usRet=DosSetPathInfo(szFileName, /* Delete EA's by saying cbValue=0 */
SetInfoLevel2,
(PVOID) &eaopWrite,
(USHORT) sizeof(EAOP),
DSPI_WRTTHRU,
0L);
pDLnext = pDL->next; /* Temp hold next pDL */
FreeMem(pDL->EAName, pFEA->cbName+1); /* Free up current Del struct */
FreeMem(pDL, sizeof(DELETELIST));
pDL = pDLnext; /* Set pDL to saved value */
}
pDelList = NULL; /* DelList is now empty */
while(pHFEA) /* Go through each HoldFEA */
{
usMemNeeded = sizeof(FEALIST) + pHFEA->cbName+1 + pHFEA->cbValue;
GetMem(aPtr,usMemNeeded);
eaopWrite.fpFEAList = (FEALIST far *) aPtr; /* Fill in eaop struct */
eaopWrite.fpFEAList->cbList = usMemNeeded;
eaopWrite.fpFEAList->list[0].fEA = pHFEA->fEA;
eaopWrite.fpFEAList->list[0].cbName = pHFEA->cbName;
eaopWrite.fpFEAList->list[0].cbValue = pHFEA->cbValue;
strcpy(aPtr + sizeof(FEALIST), pHFEA->szName);
memcpy(aPtr + sizeof(FEALIST) + pHFEA->cbName+1,
pHFEA->aValue, pHFEA->cbValue);
usRet=DosSetPathInfo(szFileName, /* Write out the EA */
SetInfoLevel2,
(PVOID) &eaopWrite,
(USHORT) sizeof(EAOP),
DSPI_WRTTHRU,0L);
FreeMem(aPtr,usMemNeeded); /* Free up the FEALIST struct */
pHFEA = pHFEA->next;
}
FILE_CHANGED = FALSE;
}
/*
* Function name: EditEAValue()
*
* Parameters: hwnd is the current window handle.
* pPDat is a pointer to PassData which contains Edit EA info.
*
* Returns: TRUE iff the edit was successful.
*
* Purpose: This routine allows the entry/edit of an EA value.
* condition in memory. First, all EAs in the delete list are
* removed from the disk, then all EAs in the pHoldFEA list are
* written out to disk.
*
* Usage/Warnings: Expects the PassData structure to tell it the HoldFEA
* to edit, and if it is a subfield of a multi-multi EA,
* the rest of the PassData structure will be filled in
* to indicated which m-m is being edited. Note that if
* this is a new edit, usRetEAType is expected to be set
* to the proper EA type upon entry. NOTE: memory sizing
* requests are not fully error trapped.
*
* Calls: MultiTypeIndex(), ChangeName(), AsciiEditProc() (thru PM),
* MultiTypeProc() (thru PM).
*/
BOOL EditEAValue(HWND hwnd, PASSDATA *pPDat)
{
USHORT usEAType; /* Holds the field type to be edited */
USHORT *pusPtr;
USHORT usSize; /* Holds the delta difference of the old and new buffers */
CHAR *szNew,*szTrash; /* Temporary pointers */
PASSDATA PDat;
HOLDFEA *pFEA = (HOLDFEA *) pPDat->Point; /* The EA to be edited */
/* Determine the type of EA that will be edited */
if(pPDat->cbMulti) /* It's a multi-type job */
{
pusPtr = (USHORT *) MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset,
pPDat->usIndex);
usEAType = *pusPtr;
}
else if(pFEA->cbValue) /* It isn't a new EA name */
{
pusPtr = (USHORT *) pFEA->aValue;
usEAType = *pusPtr;
}
else /* It's a new EA */
{
usEAType = ConvTable[usRetEAType].usPrefix;
}
PDat.Point = pFEA->szName; /* General setup for AsciiEditProc */
PDat.usIndex = pPDat->cbMulti ? 1 : 0; /* =1 if there is a multi */
PDat.fFlag = (BYTE) ((pFEA->fEA & 0x80) ? TRUE : FALSE);
switch(usEAType)
{
case EA_ASCIIZ:
case EA_ASCIIZFN:
case EA_ASCIIZEA:
case EA_ASN1:
if(pPDat->cbMulti) /* It is a multi-type field */
szAscii=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex)
+sizeof(USHORT);
else if(pFEA->cbValue) /* There is a current value */
szAscii=pFEA->aValue+sizeof(USHORT);
else /* It's a new EA */
szAscii=NULL;
if(!WinDlgBox(HWND_DESKTOP, /* Do an ascii text edit */
hwnd,
AsciiEditProc,
(HMODULE) NULL,
IDD_ASCIIEDIT,
&PDat))
return(FALSE); /* They said cancel */
if(PDat.fFlag) /* Handle the need/nice bit */
PDat.fFlag = 0x80;
if(PDat.fFlag != (BYTE) (PDat.fFlag & 0x80))
FILE_CHANGED = TRUE;
pFEA->fEA = (BYTE) (pFEA->fEA & 0x7f) | PDat.fFlag;
if(stricmp(strupr(szEAName),pFEA->szName)) /* The name changed */
ChangeName(hwnd,pFEA,szEAName);
if(pFEA->cbValue) /* There is a current value */
{
if(!strcmp(szAscii,szScratch)) /* It hasn't changed */
return(TRUE);
if(pPDat->cbMulti) /* Do the whole thing here if m-m */
{
usSize = strlen(szScratch)-strlen(szAscii); /* Change in size */
if(usSize > 0) /* The new string is longer */
{
ResizeMem(pFEA->aValue, /* Enlarge the EA size */
pFEA->cbValue,
pFEA->cbValue+usSize);
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex+1);
memmove(szTrash+usSize, /* Move end of EA to make room */
szTrash,
pFEA->cbValue-(szTrash-pFEA->aValue));
}
else /* The new string is shorter */
{
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex+1);
memmove(szTrash+usSize, /* Move back the end of the EA */
szTrash,
pFEA->cbValue-(szTrash-pFEA->aValue));
ResizeMem(pFEA->aValue, /* Shrink the EA buffer */
pFEA->cbValue,
pFEA->cbValue+usSize);
}
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex);
strcpy(szTrash+sizeof(USHORT),szScratch); /* Copy in new val */
pFEA->cbValue+=usSize; /* Change buffer count */
return(FILE_CHANGED = TRUE); /* Done with m-m edit */
}
else
{
FreeMem(pFEA->aValue,pFEA->cbValue); /* Release old Value mem */
}
}
GetMem(szNew,strlen(szScratch)+3); /* +3 for Type & NULL */
pusPtr = (USHORT *) szNew;
*pusPtr= usEAType; /* Set type in new buffer */
strcpy(szNew+2,szScratch); /* Copy in the new value */
pFEA->aValue = szNew; /* Fix up the structure */
pFEA->cbValue= strlen(szScratch)+3;
return(FILE_CHANGED = TRUE);
case EA_LPBINARY:
case EA_LPASCII:
case EA_LPMETAFILE:
if(pPDat->cbMulti) /* It is a multi-type field */
{ /* szTrash points to field to edit, pusPtr to the field length */
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex);
pusPtr = (USHORT *) ((CHAR *) szTrash + sizeof(USHORT));
usSize = *pusPtr;
if(usSize) /* It isn't a new EA */
{
GetMem(szAscii,usSize+1); /* Set up inital value for edit */
memcpy(szAscii,szTrash+2*sizeof(USHORT),usSize);
szAscii[usSize]=0;
}
else /* No inital value */
szAscii = NULL;
}
else if(pFEA->cbValue)
{
usSize=GetUSHORT(pFEA,1); /* Get size and set inital value */
if(usSize)
{
GetMem(szTrash,usSize+1); /* +1 for null */
memcpy(szTrash,pFEA->aValue+4,usSize);
szTrash[usSize]=0;
szAscii=szTrash;
}
else
szAscii = NULL;
}
else
szAscii = NULL;
if(!WinDlgBox(HWND_DESKTOP, /* Do an ascii text edit */
hwnd,
AsciiEditProc,
(HMODULE) NULL,
IDD_ASCIIEDIT,
&PDat))
{ /* Cancel, but check if memory needs to be freed before exit */
if(pPDat->cbMulti || pFEA->cbValue)
if(szAscii) /* It's not NULL */
FreeMem(szAscii,strlen(szAscii)+1); /* +1 for NULL */
return(FALSE);
}
if(PDat.fFlag) /* Handle the need/nice bit */
PDat.fFlag = 0x80;
if(PDat.fFlag != (BYTE) (PDat.fFlag & 0x80))
FILE_CHANGED = TRUE;
pFEA->fEA = (BYTE) (pFEA->fEA & 0x7f) | PDat.fFlag;
if(stricmp(strupr(szEAName),pFEA->szName)) /* The name changed */
ChangeName(hwnd,pFEA,szEAName);
if(pFEA->cbValue) /* There is a current value */
{
if(!strcmp(szAscii,szScratch)) /* It hasn't changed */
{
if(szAscii)
FreeMem(szAscii,usSize+1);
return(TRUE);
}
if(szAscii) /* Free default value buffer */
FreeMem(szAscii,usSize+1);
if(pPDat->cbMulti) /* Do the whole thing here is multi-type */
{
USHORT usDelta = strlen(szScratch) - usSize; /* Change in len */
if(usDelta > 0) /* The new string is longer, resize first */
{
ResizeMem(pFEA->aValue,pFEA->cbValue,pFEA->cbValue+usDelta);
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex+1);
memmove(szTrash+usDelta,szTrash,
pFEA->cbValue-(szTrash-pFEA->aValue));
}
else /* move first, resize afterwards */
{
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex+1);
memmove(szTrash+usDelta,szTrash,
pFEA->cbValue-(szTrash-pFEA->aValue));
ResizeMem(pFEA->aValue,pFEA->cbValue,pFEA->cbValue+usDelta);
}
szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex);
memmove(szTrash+2*sizeof(USHORT),szScratch,strlen(szScratch));
pusPtr = (USHORT *) ((CHAR *) szTrash + sizeof(USHORT));
*pusPtr= strlen(szScratch); /* Set the length field */
pFEA->cbValue += usDelta; /* Adjust struct len field */
return(FILE_CHANGED = TRUE);
}
FreeMem(pFEA->aValue,pFEA->cbValue); /* Free up old value */
}
GetMem(szNew,strlen(szScratch)+4); /* Get space for new value */
pusPtr = (USHORT *) szNew;
*pusPtr= usEAType; /* Set type field */
pusPtr++;
*pusPtr= strlen(szScratch); /* Set length field */
memcpy(szNew+4,szScratch,*pusPtr); /* Copy in new value */
pFEA->aValue = szNew; /* Adjust pointers */
pFEA->cbValue= strlen(szScratch)+4; /* +4 for type and LP cnt */
return(FILE_CHANGED = TRUE);
case EA_MVMT: /* It's multi-value multi-type */
if(pFEA->cbValue == 0) /* It's a new EA */
{
GetMem(pFEA->aValue,3*sizeof(USHORT)); /* Allocate empty m-m EA */
pFEA->cbValue = 3*sizeof(USHORT);
pusPtr = (USHORT *) pFEA->aValue;
*pusPtr = 0xffdf; /* Multi-value, multi-type */
pusPtr+=2; /* Skip type, codepage */
*pusPtr = 0; /* No fields initially */
FILE_CHANGED = TRUE;
}
/* Set up passed in data */
if(pPDat->cbMulti) /* It's a multi-type job */
{
szNew = MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex);
szTrash = MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
pPDat->usIndex+1);
PDat.usMultiOffset = szNew - pFEA->aValue;
PDat.cbMulti = szTrash - szNew;
}
else
{
PDat.usMultiOffset = 0;
PDat.cbMulti = pFEA->cbValue;
}
PDat.Point = (CHAR *) pFEA;
WinDlgBox(HWND_DESKTOP, /* Do the Multi-type edit */
hwnd,
MultiTypeProc,
(HMODULE) NULL,
IDD_MULTIBOX,
&PDat);
return(TRUE);
}
}
/*
* Function name: EAExists()
*
* Parameters: szEAName points to the EA Name to check for.
*
* Returns: TRUE iff an EA with a name matching szEAName exists.
*
* Purpose: This routine goes through the linked list pointed to by global
* pHoldFEA and determines whether or not an EA of the passed name
* already exists.
*
* Usage/Warnings: The comparison is NOT case sensitive.
*
* Calls:
*
*/
BOOL EAExists(CHAR *szEAName)
{
HOLDFEA *phFEA=pHoldFEA;
while(phFEA)
{
if(!stricmp(szEAName,phFEA->szName))
return(TRUE);
phFEA=phFEA->next;
}
return(FALSE);
}
/*
* Function name: ChangeName()
*
* Parameters: hwnd is the current window used for error messages.
* pFEA points to the current FEA.
* szName points to the new EA name.
*
* Returns: VOID. Fixes up the pFEA structure and global pDelList.
*
* Purpose: This routine copies the current EA Name to the delete list, then
* allocates a new space, copies the new name into it, and sets the
* FEA pointer to it.
*
* Usage/Warnings: NOTE: Not all the memory allocations are fully error
* trapped.
*
* Calls:
*
*/
VOID ChangeName(HWND hwnd,HOLDFEA *pFEA,CHAR *szName)
{
CHAR *szTemp;
DELETELIST *pDL;
GetMem(szTemp,strlen(szName+1)); /* Allocate space for new name */
if(!szTemp)
return;
GetMem(pDL,(USHORT) sizeof(DELETELIST)); /* Allocate a new delete struct */
pDL->EAName = pFEA->szName; /* Fill in DeleteList struct */
pDL->next = pDelList;
pDelList = pDL;
strcpy(szTemp,szName); /* Copy name to permanent buffer */
pFEA->szName = szTemp; /* Fix up struct */
pFEA->cbName = (CHAR) strlen(szName);
FILE_CHANGED = TRUE;
}
/*
* Function name: MultiTypeIndex()
*
* Parameters: pMulti points to the current m-m field.
* usIndex is the field the caller is interested in.
*
* Returns: a pointer to the field specified by the usIndex param.
*
* Purpose: This routine takes a pointer to a Multi-Multi data field and
* returns a pointer to the nth data field in this buffer.
*
* Usage/Warnings: NOTE: Memory bounds are not checked and a corrupt
* EA field could cause unspecified results.
* Recursively calls itself to handle nesting. Does not
* support multi-value single type fields.
*
* Calls: LookupEAType, MultiTypeIndex()
*
*/
CHAR *MultiTypeIndex(CHAR *pMulti, USHORT usIndex)
{
USHORT *pusPtr;
USHORT usOffset;
pMulti += 3*sizeof(USHORT); /* skip over 0xffdf, codepage, and field cnt */
while(usIndex--) /* loop to skip over correct # of flds */
{
pusPtr = (USHORT *) pMulti;
usOffset = LookupEAType(*pusPtr); /* Get offset of field type */
pMulti += sizeof(USHORT); /* Skip over the type field */
switch(ConvTable[usOffset].usFldType)
{
case IDD_ASCIIZ:
while(*pMulti++); /* Increment to point after NULL */
break;
case IDD_LPDATA:
pusPtr = (USHORT *) pMulti; /* Get the length */
pMulti += *pusPtr + sizeof(USHORT); /* skip to end */
break;
case IDD_MULTILIST:
if(*pusPtr == EA_MVMT) /* m-m, do a recursive call to skip fld */
{
pusPtr = (USHORT *) pMulti; /* points to field cnt */
pMulti = MultiTypeIndex(pMulti-sizeof(USHORT),*pusPtr);
break;
}
/* Not yet implemented for Multi-valued single-type stuff... */
break;
}
}
return(pMulti);
}
/*
* Function name: EAValueString()
*
* Parameters: hwnd is the current window handle.
* aEAVal is a pointer to an EA value field.
*
* Returns: a pointer to an ASCII description of the field value.
*
* Purpose: This routine takes a pointer to an EA Value (i.e. starting with
* with $ffxx) and returns a pointer to a string representing the
* value of the EA. This string must be Freed by the user when
* finished with it.
*
* Usage/Warnings: NOTE: Not all GetMem's are totally error trapped.
* The string returned is allocated in this procedure,
* but it is the caller's responsibility to free the buffer.
*
* Calls:
*
*/
CHAR *EAValueString(HWND hwnd,CHAR *aEAVal)
{
USHORT *pusPtr= (USHORT *) aEAVal; /* Points to EA Type */
CHAR *szRet,*szTemp; /* szRet points to return string */
switch(*pusPtr)
{
case EA_ASCIIZ: /* For asciiz strings, return MAXSHOWSIZE-1 chars */
case EA_ASCIIZFN:
case EA_ASCIIZEA:
case EA_ASN1:
aEAVal += sizeof(USHORT);
if(strlen(aEAVal)<MAXSHOWSIZE)
{
GetMem(szRet,strlen(aEAVal)+1);
strcpy(szRet,aEAVal);
}
else
{
GetMem(szRet,MAXSHOWSIZE);
strncpy(szRet,aEAVal,MAXSHOWSIZE-4);
strcpy (szRet+MAXSHOWSIZE-4,"...");
szRet[MAXSHOWSIZE-1]=0;
}
return(szRet);
case EA_LPASCII: /* Display up to first MAXSHOWSIZE-1 chars */
case EA_LPMETAFILE:
pusPtr++;
aEAVal += 2*sizeof(USHORT);
if(*pusPtr < MAXSHOWSIZE)
{
GetMem(szRet,*pusPtr +1);
strncpy(szRet,aEAVal,*pusPtr);
szRet[*pusPtr]=0;
}
else
{
GetMem(szRet,MAXSHOWSIZE);
strncpy(szRet,aEAVal,MAXSHOWSIZE-4);
strcpy (szRet+MAXSHOWSIZE-4,"...");
szRet[MAXSHOWSIZE-1]=0;
}
return(szRet);
/* For the rest of the types, just display the field type */
case EA_LPBINARY:
szTemp = "*** LP Binary ***";
break;
case EA_LPBITMAP:
szTemp = "*** LP Bitmap ***";
break;
case EA_LPICON:
szTemp = "*** LP Icon ***";
break;
case EA_MVMT:
szTemp = "*** Multi-value Multi-type ***";
break;
case EA_MVST:
szTemp = "*** Multi-value Single-type ***";
break;
default:
szTemp = "*** Unknown EA type ***";
break;
}
GetMem(szRet,strlen(szTemp)+1); /* Copy string from static to dynamic */
strcpy(szRet,szTemp);
return(szRet);
}
/*
* Function name: MultiAdd()
*
* Parameters: hwnd is the current window handle.
* pFEA points to the current FEA.
* pPDat gives the current m-m data.
*
* Returns: VOID. Modifies the current pFEA.
*
* Purpose: This routine is called by MultiTypeProc and handles the addition
* of a subvalue to a multi-value, multi-type EA.
*
* Usage/Warnings: NOTE: Not all GetMem's are totally error trapped.
* It is also possible that the add to the listbox could fail.
*
* Calls: AddEAProc() (thru PM), MultiTypeIndex()
*
*/
VOID MultiAdd(HWND hwnd, HOLDFEA *pFEA,PASSDATA FAR *pPDat)
{
USHORT usSize;
USHORT *pusPtr;
CHAR aUtility[6]; /* Used to hold the header for all EA types */
CHAR *pInsert,*pValue;
PASSDATA PDat;
PDat.Point = pFEA->szName;
if(!WinDlgBox(HWND_DESKTOP, /* Get the name and type */
hwnd,
AddEAProc,
(HMODULE) NULL,
IDD_ADDEA,
&PDat))
return; /* They said cancel */
pusPtr = (USHORT *) aUtility;
*pusPtr= ConvTable[usRetEAType].usPrefix; /* Set the type in header buf */
switch(ConvTable[usRetEAType].usFldType)
{
case IDD_ASCIIZ: /* make buffer look like: xx FF 00, size 3 */
usSize = 3;
aUtility[2]=0;
break;
case IDD_LPDATA: /* make the buffer look like: xx FF 00 00, size 4 */
usSize = 4;
pusPtr = (USHORT *) &aUtility[2];
*pusPtr= 0;
break;
case IDD_MULTILIST:
usSize = 6;
pusPtr = (USHORT *) &aUtility[2];
*pusPtr= 0; /* Zero out codepage */
pusPtr++;
*pusPtr= 0; /* Zero out fld cnt */
break;
}
/* Increase EA size to accomodate the header */
ResizeMem(pFEA->aValue,pFEA->cbValue,pFEA->cbValue+usSize);
pusPtr = (USHORT *) ((CHAR *) pFEA->aValue + pPDat->usMultiOffset);
pusPtr+=2; /* Point to the current number of m-m fields */
/* Get ptr to beginning of current EA, scoot the rest down and insert
the 3-4 byte header at the end of the list. */
pInsert = MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset, *pusPtr);
memmove(pInsert+usSize,pInsert, pFEA->cbValue-(pInsert-pFEA->aValue));
memcpy(pInsert,aUtility,usSize);
pFEA->cbValue += usSize; /* Fix up the counts */
pPDat->cbMulti+= usSize;
/* Set the PDat for call */
PDat.Point = (CHAR *) pFEA;
PDat.cbMulti = pPDat->cbMulti;
PDat.usMultiOffset = pPDat->usMultiOffset;
PDat.usIndex = *pusPtr;
if(!EditEAValue(hwnd,&PDat)) /* They canceled the edit */
{ /* Move the EA's back to effectively kill the inserted header */
memmove(pInsert,pInsert+usSize,pFEA->cbValue-(pInsert-pFEA->aValue));
ResizeMem(pFEA->aValue,pFEA->cbValue,pFEA->cbValue-usSize);
pFEA->cbValue -= usSize; /* Adjust counters */
pPDat->cbMulti-= usSize;
return;
}
/* Reset pusPtr since EditEAValue could have moved the base address */
pusPtr = (USHORT *) ((CHAR *) pFEA->aValue + pPDat->usMultiOffset);
pusPtr+=2;
pInsert = MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset, *pusPtr);
*pusPtr += 1; /* Field cnt incremented AFTER call to Edit */
pValue = EAValueString(hwnd,pInsert); /* Add new field to the list box */
WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_INSERTITEM,
MPFROM2SHORT(LIT_END,0),
MPFROMP(pValue));
FreeMem(pValue,strlen(pValue)+1);
FILE_CHANGED = TRUE;
}
