![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to neadea.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / nead|
Return to neadea.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / nead |
1.1 root 1: /*************************************************************
2:
3: This module contains subroutines for nead.c that specifically
4: deal with the manipulation of EAs.
5:
6: Procedures in this file:
7: AddEA() Handles the Add button press
8: QueryEAs() Reads in all the EAs associated with a file
9: CheckEAIntegrity() Checks an EA buffer to see if it is valid
10: Free_FEAList() Deallocates memory associated with EA list
11: LookupEAType() Gets an offset into table for an EA type
12: DeleteCurEA() Deletes the highlighted EA
13: CurEAType() Returns EA Type given a HoldFEA ptr
14: GetUSHORT() Returns nth USHORT in ->aValue
15: WriteEAs() Updates EAs state on the disk
16: EditEAValues() Handles editing a given EA (also m-m EAs)
17: EAExists() Determines if the given EA Name exists
18: ChangeName() Handles the change of an EA's name
19: MultiTypeIndex() Gets a specific field in a m-m structure
20: EAValueString() Returns a representational string for an EA
21: MultiAdd() Handles addition of a field for m-m
22:
23: **************************************************************/
24:
25: #include "nead.h"
26:
27: /************ External GLOBALS *******************************/
28:
29: extern CHAR szFileName[CCHMAXPATH];
30: extern CHAR szEAName[MAXEANAME+1];
31: extern USHORT usRetEAType;
32: extern BOOL FILE_ISOPEN;
33: extern BOOL FILE_CHANGED;
34: extern BOOL COMMAND_LINE_FILE;
35: extern CHAR *pAlloc,*szEditBuf,*szAscii,*szScratch;
36: extern HOLDFEA *pHoldFEA;
37: extern DELETELIST *pDelList;
38: extern EADATA ConvTable[EATABLESIZE];
39:
40: /*************************************************************/
41:
42:
43: /*
44: * Function name: AddEA()
45: *
46: * Parameters: hwnd which is the current window handle.
47: *
48: * Returns: TRUE iff the EA is successfully added.
49: *
50: * Purpose: This routine handles the addition of a new EA to the linked list.
51: *
52: * Usage/Warnings: Routine does NOT do full memory error trapping and the
53: * insert message to the l-box is not error checked.
54: *
55: * Calls: EditEAValue()
56: */
57:
58: BOOL AddEA(HWND hwnd)
59: {
60: HOLDFEA *pFEA=pHoldFEA; /* Points to the beginning of the EA list */
61: HOLDFEA *pNewFEA; /* Used to temporarily hold the new EA */
62: PASSDATA PData;
63:
64: if(!FILE_ISOPEN)
65: return(FALSE);
66:
67: if(!WinDlgBox(HWND_DESKTOP, /* get new EA name and type */
68: hwnd,
69: AddEAProc,
70: NULL,
71: IDD_ADDEA,
72: NULL))
73: return(FALSE); /* they said cancel */
74:
75: GetMem((PPVOID)&pNewFEA, sizeof(HOLDFEA)); /* Allocate space for new EA struct */
76:
77: pNewFEA->cbName = (CHAR) strlen(szEAName); /* Fill in new structure */
78: pNewFEA->cbValue= 0;
79: pNewFEA->fEA = 0; /* Need bit NOT set */
80:
81: GetMem((PPVOID)&pNewFEA->szName, pNewFEA->cbName+1); /* Name returned in szEAName */
82: strcpy(pNewFEA->szName,strupr(szEAName));
83: pNewFEA->aValue = NULL;
84: pNewFEA->next = NULL;
85:
86: if(pHoldFEA == NULL) /* It's the first EA for the file */
87: {
88: pHoldFEA = pNewFEA;
89: }
90: else /* Add EA to the end of the linked list */
91: {
92: while(pFEA->next)
93: pFEA = pFEA->next;
94: pFEA->next = pNewFEA;
95: }
96: PData.Point = (CHAR *) pNewFEA; /* Setup user data for call */
97: PData.cbMulti = 0; /* to edit of the name and */
98: PData.usMultiOffset = 0; /* EA Value */
99:
100: if(!EditEAValue(hwnd,&PData)) /* They canceled the edit */
101: {
102: if(pFEA) /* It's not the only EA */
103: pFEA->next = NULL; /* Disconnect the partial new EA */
104: else
105: pHoldFEA = NULL; /* The new EA was the first one */
106:
107: FreeMem(pNewFEA->szName);
108: FreeMem(pNewFEA);
109:
110: return(FALSE);
111: }
112:
113: WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_INSERTITEM, /* Insert name in L-Box */
114: MPFROM2SHORT(LIT_END,0),
115: MPFROMP(pNewFEA->szName));
116:
117: return(TRUE);
118: }
119:
120:
121: /*
122: * Function name: QueryEAs()
123: *
124: * Parameters: hwnd which is the current window handle.
125: * pszPath points to the path of the file to grab EAs from.
126: *
127: * Returns: TRUE iff it successfully reads in the EAs. Upon exit, global
128: * pHoldFEA points to a linked list of the EAs for the current file.
129: *
130: * Purpose: Call DOS to Query a file's EA names and values.
131: *
132: * Usage/Warnings: Routine does NOT do full memory error trapping.
133: * NOTE: This routine does NOT prevent other processes
134: * from accessing the file's EAs while it is reading them
135: * in, or while the program is editing them.
136: *
137: * Calls: Free_FEAList(), CheckEAIntegrity()
138: */
139:
140: BOOL QueryEAs(CHAR *pszPath)
141: {
142: CHAR *pAlloc; /* Holds the FEA struct returned by DosEnumAttribute */
143: /* also used to create the GEALIST for DosQPathInfo */
144: CHAR *pBigAlloc; /* Temp buffer to hold each EA as it is read in */
145: USHORT cbBigAlloc; /* Size of buffer */
146:
147: ULONG ulEntryNum = 1; /* count of current EA to read (1-relative) */
148: ULONG ulEnumCnt; /* Number of EAs for Enum to return, always 1 */
149:
150: HOLDFEA *pLastIn; /* Points to last EA added, so new EA can link */
151: HOLDFEA *pNewFEA; /* Struct to build the new EA in */
152:
153: FEA *pFEA; /* Used to read from Enum's return buffer */
154: GEALIST *pGEAList; /* Ptr used to set up buffer for DosQPathInfo call */
155: EAOP eaopGet; /* Used to call DosQPathInfo */
156:
157: GetMem((PPVOID)&pAlloc, MAX_GEA); /* Allocate enough room for any GEA List */
158: pFEA = (FEA *) pAlloc; /* pFEA always uses pAlloc buffer */
159:
160: pHoldFEA = NULL; /* Reset the pointer for the EA linked list */
161:
162: while(TRUE) /* Loop continues until there are no more EAs */
163: {
164: ulEnumCnt = 1; /* Only want to get one EA at a time */
165: if(DosEnumAttribute(Ref_ASCIIZ, /* Read into pAlloc Buffer */
166: pszPath, /* Note that this does not */
167: ulEntryNum, /* get the aValue field, */
168: pAlloc, /* so DosQPathInfo must be */
169: MAX_GEA, /* called to get it. */
170: &ulEnumCnt,
171: (LONG) GetInfoLevel1))
172: break; /* There was some sort of error */
173:
174: if(ulEnumCnt != 1) /* All the EAs have been read */
175: break;
176:
177: ulEntryNum++;
178:
179: GetMem((PPVOID)&pNewFEA, sizeof(HOLDFEA));
180:
181: if (pNewFEA == NULL) /* Out of memory */
182: {
183: FreeMem(pAlloc);
184: Free_FEAList(pHoldFEA,pDelList);
185: return (FALSE);
186: }
187:
188: pNewFEA->cbName = pFEA->cbName; /* Fill in the HoldFEA structure */
189: pNewFEA->cbValue= pFEA->cbValue;
190: pNewFEA->fEA = pFEA->fEA;
191: pNewFEA->next = NULL;
192:
193: GetMem((PPVOID)&pNewFEA->szName, pFEA->cbName +1); /* Allocate for 2 arrays */
194: GetMem((PPVOID)&pNewFEA->aValue, pFEA->cbValue);
195:
196: if (!pNewFEA->szName || !pNewFEA->aValue) /* Out of memory */
197: {
198: if(pNewFEA->szName)
199: FreeMem(pNewFEA->szName);
200: if(pNewFEA->aValue)
201: FreeMem(pNewFEA->aValue);
202:
203: FreeMem(pAlloc);
204: FreeMem(pNewFEA);
205:
206: Free_FEAList(pHoldFEA,pDelList);
207: return (FALSE);
208: }
209: strcpy(pNewFEA->szName,pAlloc+sizeof(FEA)); /* Copy in EA Name */
210:
211: cbBigAlloc = sizeof(FEALIST) + pNewFEA->cbName+1 + pNewFEA->cbValue;
212: GetMem((PPVOID)&pBigAlloc, cbBigAlloc);
213: if (pBigAlloc == NULL)
214: {
215: FreeMem(pNewFEA->szName);
216: FreeMem(pNewFEA->aValue);
217: FreeMem(pAlloc);
218: FreeMem(pNewFEA);
219: Free_FEAList(pHoldFEA,pDelList);
220: return (FALSE);
221: }
222:
223: pGEAList = (GEALIST *) pAlloc; /* Set up GEAList structure */
224:
225: pGEAList->cbList = sizeof(GEALIST) + pNewFEA->cbName; /* +1 for NULL */
226: pGEAList->list[0].cbName = pNewFEA->cbName;
227: strcpy(pGEAList->list[0].szName,pNewFEA->szName);
228:
229: eaopGet.fpGEAList = (GEALIST FAR *) pAlloc;
230: eaopGet.fpFEAList = (FEALIST FAR *) pBigAlloc;
231:
232: eaopGet.fpFEAList->cbList = cbBigAlloc;
233:
234: DosQPathInfo(pszPath, /* Get the complete EA info */
235: GetInfoLevel3,
236: (PVOID) &eaopGet,
237: sizeof(EAOP));
238: memcpy(pNewFEA->aValue, /* Copy the value to HoldFEA */
239: pBigAlloc+sizeof(FEALIST)+pNewFEA->cbName+1,
240: pNewFEA->cbValue);
241:
242: FreeMem(pBigAlloc); /* Release the temp Enum buffer */
243:
244: if(!CheckEAIntegrity(pNewFEA->aValue,pNewFEA->cbValue)) /* Bad EA */
245: {
246: FreeMem(pNewFEA->szName);
247: FreeMem(pNewFEA->aValue);
248: FreeMem(pNewFEA);
249: continue; /* Don't add this EA to linked list */
250: }
251:
252: if(pHoldFEA == NULL) /* If first EA, set pHoldFEA */
253: pHoldFEA = pNewFEA;
254: else /* Otherwise, add to end of list */
255: pLastIn->next = pNewFEA;
256:
257: pLastIn = pNewFEA; /* Update the end of the list */
258: }
259: FreeMem(pAlloc); /* Free up the GEA buf for DosEnum */
260: return (TRUE);
261: }
262:
263:
264: /*
265: * Function name: CheckEAIntegrity()
266: *
267: * Parameters: aBuf points to the buffer to check for a valid EA.
268: * cbBuf is the allocated length of aBuf.
269: *
270: * Returns: TRUE iff the buffer is a valid EA structure.
271: *
272: * Purpose: This routine checks the integrity of the passed EA buffer by
273: * seeing if there are any non-standard EA types, or bad data that
274: * isn't sized correctly.
275: *
276: * Usage/Warnings: Routine uses MultiTypeIndex() to check m-m type EAs
277: * since they are potentially recursive. However, this
278: * may not be a good idea if the m-m EA is severly
279: * corrupted because it may cause MTI() to attempt a read
280: * from protected memory. Routine does NOT modify the
281: * buffer under any circumstance.
282: *
283: * Calls: MultiTypeIndex()
284: */
285:
286: BOOL CheckEAIntegrity(CHAR *aBuf,USHORT cbBuf)
287: {
288: USHORT *pusPtr = (USHORT *) aBuf;
289: USHORT usOffset;
290: CHAR *aEndPtr;
291:
292: usOffset = LookupEAType(*pusPtr); /* Get the EA type */
293:
294: switch(ConvTable[usOffset].usFldType)
295: {
296: case IDD_LPDATA:
297: pusPtr++;
298: if(*pusPtr + 2*sizeof(USHORT) == cbBuf)
299: return TRUE;
300: else
301: return FALSE;
302:
303: case IDD_MULTILIST:
304: if(*pusPtr == EA_MVMT)
305: {
306: pusPtr += 2;
307:
308: /* This checks where the end of the m-m list ends to determine
309: the size of the EA. This is probably not good if the EA is
310: badly corrupted and it points to protected memory */
311:
312: aEndPtr = MultiTypeIndex(aBuf,*pusPtr);
313: if(aEndPtr - aBuf == cbBuf)
314: return TRUE;
315: else
316: return FALSE;
317: }
318: else /* Single type, multi-value is not yet implemented */
319: {
320: return TRUE;
321: }
322: default:
323: return FALSE;
324: }
325: return TRUE;
326: }
327:
328:
329: /*
330: * Function name: Free_FEAList()
331: *
332: * Parameters: pFEA points to the beginning of the linked list to be freed.
333: * pDList points to the beginning of the deleted linked list.
334: *
335: * Returns: VOID. The two linked lists passed in are cleaned out though.
336: *
337: * Purpose: This routine frees up the current list of EAs by deallocating
338: * the space used by the szName and aValue fields, then deallocating
339: * the HoldFEA struct. Next, it deletes the EAName space, then the
340: * DeleteList structure.
341: *
342: * Usage/Warnings: Note that NEAD always passes in pHoldFEA and pDelList
343: * which is unnecessary since they are global pointers;
344: * however, this is done to make the routine more flexible
345: * by allowing multiple linked lists to exist.
346: *
347: * Calls:
348: */
349:
350: VOID Free_FEAList(HOLDFEA *pFEA,DELETELIST *pDList)
351: {
352: HOLDFEA *next; /* Holds the next field since we free the structure */
353: /* before reading the current next field */
354: DELETELIST *Dnext; /* Same purpose as *next */
355:
356: while(pFEA)
357: {
358: next = pFEA->next;
359: if(pFEA->szName) /* Free if non-NULL name */
360: FreeMem(pFEA->szName);
361: if(pFEA->aValue) /* Free if non-NULL value */
362: FreeMem(pFEA->aValue);
363:
364: FreeMem(pFEA); /* Free HoldFEA struct */
365: pFEA = next;
366: }
367:
368: while(pDList)
369: {
370: Dnext = pDList->next;
371: if(pDList->EAName)
372: FreeMem(pDList->EAName);
373: FreeMem(pDList);
374: pDList = Dnext;
375: }
376: }
377:
378:
379: /*
380: * Function name: LookupEAType()
381: *
382: * Parameters: usType is tye EA type to be looked up.
383: *
384: * Returns: An offset into the ConvTable to the appropriate entry. If no
385: * match is found, the return value points to the last entry,
386: * non-conventional format.
387: *
388: * Purpose: This routine takes EA type and returns an offset into ConvTable
389: * which points to an entry that describes the type passed in.
390: *
391: * Usage/Warnings:
392: *
393: * Calls:
394: */
395:
396: USHORT LookupEAType(USHORT usType)
397: {
398: USHORT cnt;
399:
400: for(cnt=0;cnt<EATABLESIZE-1;cnt++)
401: if(ConvTable[cnt].usPrefix == usType)
402: return(cnt);
403: return(cnt);
404: }
405:
406:
407: /*
408: * Function name: DeleteCurEA()
409: *
410: * Parameters: hwnd is the current window handle.
411: *
412: * Returns: VOID. Removes one item from global pHoldFEA list and adds one
413: * to global pDelList.
414: *
415: * Purpose: This routine removes in memory the currently highlighted EA from
416: * the EA list. It places the deleted EA in the global pDelList
417: * linked list.
418: *
419: * Usage/Warnings: The memory allocation routines are NOT fully error trapped.
420: *
421: * Calls: GetCurFEA()
422: */
423:
424: VOID DeleteCurEA(HWND hwnd)
425: {
426: HOLDFEA *pFEA,*pFEAPrev;
427: DELETELIST *pDL,*pDLcnt; /* Utility ptrs for manipulating the Del list */
428: LONG lOffset;
429:
430: pFEA = GetCurFEA(hwnd,pHoldFEA); /* Gets a pointer to item to delete */
431: if (pFEA == NULL)
432: return;
433:
434: /* These two allocations should be checked for out of memory */
435: GetMem((PPVOID)&pDL, sizeof(DELETELIST)); /* Add Name to Delete List */
436: GetMem((PPVOID)&pDL->EAName, pFEA->cbName+1);
437: strcpy(pDL->EAName,pFEA->szName);
438: pDL->next = NULL;
439:
440: if(pDelList == NULL) /* The del list was previously empty */
441: pDelList = pDL;
442: else /* tack name onto the end of the list */
443: {
444: pDLcnt = pDelList;
445: while(pDLcnt->next)
446: pDLcnt = pDLcnt->next;
447: pDLcnt->next = pDL;
448: }
449:
450: lOffset = (LONG) WinSendDlgItemMsg(hwnd, IDD_LBOX,
451: LM_QUERYSELECTION,0,0);
452: WinSendDlgItemMsg(hwnd, IDD_LBOX,
453: LM_DELETEITEM,MPFROMSHORT((SHORT) lOffset),0L);
454:
455: if(lOffset<1) /* Remove pFEA from the linked list */
456: {
457: pHoldFEA = pFEA->next;
458: }
459: else
460: {
461: pFEAPrev = pHoldFEA;
462:
463: while(--lOffset) /* Find previous EA */
464: pFEAPrev = pFEAPrev->next;
465:
466: pFEAPrev->next = pFEA->next;
467: }
468:
469: FreeMem(pFEA->szName); /* Release the memory */
470: FreeMem(pFEA->aValue);
471: FreeMem(pFEA);
472:
473: FILE_CHANGED = TRUE;
474: }
475:
476:
477: /*
478: * Function name: CurEAType()
479: *
480: * Parameters: pFEA points to the FEA struct to use.
481: *
482: * Returns: The EA type.
483: *
484: * Purpose: Given an EA structure, this routine returns the Type of the EA
485: * which resides in the first USHORT of the aValue member.
486: * This function is the same as GetUSHORT(pFEA,0)
487: *
488: * Usage/Warnings: Assumes a valid HoldFEA struct.
489: *
490: * Calls:
491: */
492:
493: USHORT CurEAType(HOLDFEA *pFEA) /* Same as GetUSHORT(,0); */
494: {
495: USHORT *pusType; /* EA Type is stored in first USHORT of aValue field */
496:
497: pusType = (USHORT *) pFEA->aValue;
498: return(*pusType);
499: }
500:
501:
502: /*
503: * Function name: GetUSHORT()
504: *
505: * Parameters: pFEA points to the FEA struct to use.
506: * index is an offset of the USHORT to be returned
507: *
508: * Returns: The appropriate USHORT from the aValue field
509: *
510: * Purpose: This routine returns the nth USHORT value in the aValue member
511: * of pFEA using index as the offset.
512: *
513: * Usage/Warnings: Assumes a valid HoldFEA struct and that index doesn't
514: * point outside the aValue buffer.
515: *
516: * Calls:
517: */
518:
519: USHORT GetUSHORT(HOLDFEA *pFEA,USHORT index)
520: {
521: USHORT *pusType;
522:
523: pusType = (USHORT *) pFEA->aValue;
524: while(index-- > 0)
525: pusType++;
526: return(*pusType);
527: }
528:
529:
530: /*
531: * Function name: WriteEAs()
532: *
533: * Parameters: hwnd is the current window handle used only by memory
534: * allocation error handling.
535: *
536: * Returns: VOID. But cleans out the pDelList linked list.
537: *
538: * Purpose: This routine updates the EAs on disk to reflect their current
539: * condition in memory. First, all EAs in the delete list are
540: * removed from the disk, then all EAs in the pHoldFEA list are
541: * written out to disk.
542: *
543: * Usage/Warnings: NOTE: This routine is not bulletproof as it does not get
544: * exclusive access to the file EAs, nor does it handle out
545: * of disk space sort of errors. Also, memory fetches are
546: * not fully error trapped.
547: *
548: * Calls:
549: */
550:
551: VOID WriteEAs()
552: {
553: DELETELIST *pDL = pDelList,*pDLnext;
554: HOLDFEA *pHFEA= pHoldFEA;
555: EAOP eaopWrite;
556: CHAR aBuf[MAX_GEA],*aPtr;
557: FEA *pFEA = (FEA *) &aBuf[sizeof(ULONG)];
558: USHORT usRet,usMemNeeded;
559: ULONG *pulPtr=(ULONG *) aBuf; /* Initally points to top of FEALIST */
560:
561: if(!FILE_ISOPEN || !FILE_CHANGED) /* Don't write unless it's necessary */
562: return;
563:
564: eaopWrite.fpFEAList = (FEALIST FAR *) aBuf; /* Setup fields that won't */
565: pFEA->fEA = 0; /* change for the delete */
566: pFEA->cbValue = 0; /* calls to DosSetPathInfo */
567:
568: while(pDL) /* Clean out all the deleted EA names */
569: {
570: pFEA->cbName = (UCHAR) strlen(pDL->EAName);
571: *pulPtr = sizeof(FEALIST) + pFEA->cbName+1; /* +1 for NULL */
572: strcpy(aBuf+sizeof(FEALIST),pDL->EAName);
573:
574: usRet=DosSetPathInfo(szFileName, /* Delete EA's by saying cbValue=0 */
575: SetInfoLevel2,
576: (PVOID) &eaopWrite,
577: (USHORT) sizeof(EAOP),
578: DSPI_WRTTHRU);
579:
580: pDLnext = pDL->next; /* Temp hold next pDL */
581: FreeMem(pDL->EAName); /* Free up current Del struct */
582: FreeMem(pDL);
583: pDL = pDLnext; /* Set pDL to saved value */
584: }
585: pDelList = NULL; /* DelList is now empty */
586:
587: while(pHFEA) /* Go through each HoldFEA */
588: {
589: usMemNeeded = sizeof(FEALIST) + pHFEA->cbName+1 + pHFEA->cbValue;
590: GetMem((PPVOID)&aPtr, usMemNeeded);
591:
592: eaopWrite.fpFEAList = (FEALIST FAR *) aPtr; /* Fill in eaop struct */
593: eaopWrite.fpFEAList->cbList = usMemNeeded;
594:
595: eaopWrite.fpFEAList->list[0].fEA = pHFEA->fEA;
596: eaopWrite.fpFEAList->list[0].cbName = pHFEA->cbName;
597: eaopWrite.fpFEAList->list[0].cbValue = pHFEA->cbValue;
598:
599: strcpy(aPtr + sizeof(FEALIST), pHFEA->szName);
600: memcpy(aPtr + sizeof(FEALIST) + pHFEA->cbName+1,
601: pHFEA->aValue, pHFEA->cbValue);
602:
603: usRet=DosSetPathInfo(szFileName, /* Write out the EA */
604: SetInfoLevel2,
605: (PVOID) &eaopWrite,
606: (USHORT) sizeof(EAOP),
607: DSPI_WRTTHRU);
608:
609: FreeMem(aPtr); /* Free up the FEALIST struct */
610:
611: pHFEA = pHFEA->next;
612: }
613:
614: FILE_CHANGED = FALSE;
615: }
616:
617:
618: /*
619: * Function name: EditEAValue()
620: *
621: * Parameters: hwnd is the current window handle.
622: * pPDat is a pointer to PassData which contains Edit EA info.
623: *
624: * Returns: TRUE iff the edit was successful.
625: *
626: * Purpose: This routine allows the entry/edit of an EA value.
627: * condition in memory. First, all EAs in the delete list are
628: * removed from the disk, then all EAs in the pHoldFEA list are
629: * written out to disk.
630: *
631: * Usage/Warnings: Expects the PassData structure to tell it the HoldFEA
632: * to edit, and if it is a subfield of a multi-multi EA,
633: * the rest of the PassData structure will be filled in
634: * to indicated which m-m is being edited. Note that if
635: * this is a new edit, usRetEAType is expected to be set
636: * to the proper EA type upon entry. NOTE: memory sizing
637: * requests are not fully error trapped.
638: *
639: * Calls: MultiTypeIndex(), ChangeName(), AsciiEditProc() (thru PM),
640: * MultiTypeProc() (thru PM).
641: */
642:
643: BOOL EditEAValue(HWND hwnd, PASSDATA *pPDat)
644: {
645: USHORT usEAType; /* Holds the field type to be edited */
646: USHORT *pusPtr;
647: USHORT usSize; /* Holds the delta difference of the old and new buffers */
648: CHAR *szNew,*szTrash; /* Temporary pointers */
649: PASSDATA PDat;
650: HOLDFEA *pFEA = (HOLDFEA *) pPDat->Point; /* The EA to be edited */
651:
652: /* Determine the type of EA that will be edited */
653: if(pPDat->cbMulti) /* It's a multi-type job */
654: {
655: pusPtr = (USHORT *) MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset,
656: pPDat->usIndex);
657: usEAType = *pusPtr;
658: }
659: else if(pFEA->cbValue) /* It isn't a new EA name */
660: {
661: pusPtr = (USHORT *) pFEA->aValue;
662: usEAType = *pusPtr;
663: }
664: else /* It's a new EA */
665: {
666: usEAType = ConvTable[usRetEAType].usPrefix;
667: }
668:
669: PDat.Point = pFEA->szName; /* General setup for AsciiEditProc */
670: PDat.usIndex = pPDat->cbMulti ? 1 : 0; /* =1 if there is a multi */
671: PDat.fFlag = (BYTE) ((pFEA->fEA & 0x80) ? TRUE : FALSE);
672:
673: switch(usEAType)
674: {
675: case EA_ASCIIZ:
676: case EA_ASCIIZFN:
677: case EA_ASCIIZEA:
678: case EA_ASN1:
679: if(pPDat->cbMulti) /* It is a multi-type field */
680: szAscii=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
681: pPDat->usIndex)
682: +sizeof(USHORT);
683: else if(pFEA->cbValue) /* There is a current value */
684: szAscii=pFEA->aValue+sizeof(USHORT);
685: else /* It's a new EA */
686: szAscii=NULL;
687:
688:
689: if(!WinDlgBox(HWND_DESKTOP, /* Do an ascii text edit */
690: hwnd,
691: AsciiEditProc,
692: NULL,
693: IDD_ASCIIEDIT,
694: &PDat))
695: return(FALSE); /* They said cancel */
696:
697: if(PDat.fFlag) /* Handle the need/nice bit */
698: PDat.fFlag = 0x80;
699: if(PDat.fFlag != (PDat.fFlag & 0x80))
700: FILE_CHANGED = TRUE;
701: pFEA->fEA = (pFEA->fEA & 0x7f) | PDat.fFlag;
702:
703: if(stricmp(strupr(szEAName),pFEA->szName)) /* The name changed */
704: ChangeName(pFEA,szEAName);
705:
706: if(pFEA->cbValue) /* There is a current value */
707: {
708: if(!strcmp(szAscii,szScratch)) /* It hasn't changed */
709: return(TRUE);
710:
711: if(pPDat->cbMulti) /* Do the whole thing here if m-m */
712: {
713: usSize = strlen(szScratch)-strlen(szAscii); /* Change in size */
714:
715: if(usSize > 0) /* The new string is longer */
716: {
717: ResizeMem(pFEA->aValue, /* Enlarge the EA size */
718: pFEA->cbValue,
719: pFEA->cbValue+usSize);
720: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
721: pPDat->usIndex+1);
722: memmove(szTrash+usSize, /* Move end of EA to make room */
723: szTrash,
724: pFEA->cbValue-(szTrash-pFEA->aValue));
725: }
726: else if(usSize < 0) /* The new string is shorter */
727: {
728: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
729: pPDat->usIndex+1);
730: memmove(szTrash+usSize, /* Move back the end of the EA */
731: szTrash,
732: pFEA->cbValue-(szTrash-pFEA->aValue));
733: DosSetMem(pFEA->aValue, pFEA->cbValue+usSize, fPERM|PAG_COMMIT);
734: }
735: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
736: pPDat->usIndex);
737: strcpy(szTrash+sizeof(USHORT),szScratch); /* Copy in new val */
738: pFEA->cbValue+=usSize; /* Change buffer count */
739:
740: return(FILE_CHANGED = TRUE); /* Done with m-m edit */
741: }
742: else
743: {
744: FreeMem(pFEA->aValue); /* Release old Value mem */
745: }
746: }
747: GetMem((PPVOID)&szNew, strlen(szScratch)+3); /* +3 for Type & NULL */
748: pusPtr = (USHORT *) szNew;
749: *pusPtr= usEAType; /* Set type in new buffer */
750: strcpy(szNew+2,szScratch); /* Copy in the new value */
751: pFEA->aValue = szNew; /* Fix up the structure */
752: pFEA->cbValue= strlen(szScratch)+3;
753:
754: return(FILE_CHANGED = TRUE);
755:
756: case EA_LPBINARY:
757: case EA_LPASCII:
758: case EA_LPMETAFILE:
759: if(pPDat->cbMulti) /* It is a multi-type field */
760: { /* szTrash points to field to edit, pusPtr to the field length */
761: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
762: pPDat->usIndex);
763: pusPtr = (USHORT *) ((CHAR *) szTrash + sizeof(USHORT));
764: usSize = *pusPtr;
765: if(usSize) /* It isn't a new EA */
766: {
767: GetMem((PPVOID)&szAscii, usSize+1); /* Set up inital value for edit */
768: memcpy(szAscii,szTrash+2*sizeof(USHORT),usSize);
769: szAscii[usSize]=NULL;
770: }
771: else /* No inital value */
772: szAscii = NULL;
773: }
774: else if(pFEA->cbValue)
775: {
776: usSize=GetUSHORT(pFEA,1); /* Get size and set inital value */
777: if(usSize)
778: {
779: GetMem((PPVOID)&szTrash, usSize+1); /* +1 for null */
780: memcpy(szTrash,pFEA->aValue+4,usSize);
781: szTrash[usSize]=NULL;
782: szAscii=szTrash;
783: }
784: else
785: szAscii = NULL;
786: }
787: else
788: szAscii = NULL;
789:
790: if(!WinDlgBox(HWND_DESKTOP, /* Do an ascii text edit */
791: hwnd,
792: AsciiEditProc,
793: NULL,
794: IDD_ASCIIEDIT,
795: &PDat))
796: { /* Cancel, but check if memory needs to be freed before exit */
797: if(pPDat->cbMulti || pFEA->cbValue)
798: if(szAscii) /* It's not NULL */
799: FreeMem(szAscii); /* +1 for NULL */
800:
801: return(FALSE);
802: }
803:
804: if(PDat.fFlag) /* Handle the need/nice bit */
805: PDat.fFlag = 0x80;
806: if(PDat.fFlag != (PDat.fFlag & 0x80))
807: FILE_CHANGED = TRUE;
808: pFEA->fEA = (pFEA->fEA & 0x7f) | PDat.fFlag;
809:
810: if(stricmp(strupr(szEAName),pFEA->szName)) /* The name changed */
811: ChangeName(pFEA,szEAName);
812:
813: if(pFEA->cbValue) /* There is a current value */
814: {
815: if(!strcmp(szAscii,szScratch)) /* It hasn't changed */
816: {
817: if(szAscii)
818: FreeMem(szAscii);
819: return(TRUE);
820: }
821: if(szAscii) /* Free default value buffer */
822: FreeMem(szAscii);
823:
824: if(pPDat->cbMulti) /* Do the whole thing here is multi-type */
825: {
826: USHORT usDelta = strlen(szScratch) - usSize; /* Change in len */
827: if(usDelta > 0) /* The new string is longer, resize first */
828: {
829: ResizeMem(pFEA->aValue, pFEA->cbValue, pFEA->cbValue+usDelta);
830: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
831: pPDat->usIndex+1);
832: memmove(szTrash+usDelta,szTrash,
833: pFEA->cbValue-(szTrash-pFEA->aValue));
834: }
835: else if(usDelta < 0) /* move first, resize afterwards */
836: {
837: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
838: pPDat->usIndex+1);
839: memmove(szTrash+usDelta,szTrash,
840: pFEA->cbValue-(szTrash-pFEA->aValue));
841: ResizeMem(pFEA->aValue, pFEA->cbValue+usDelta, fPERM|PAG_COMMIT);
842: }
843: szTrash=MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
844: pPDat->usIndex);
845: memmove(szTrash+2*sizeof(USHORT),szScratch,strlen(szScratch));
846: pusPtr = (USHORT *) ((CHAR *) szTrash + sizeof(USHORT));
847: *pusPtr= strlen(szScratch); /* Set the length field */
848:
849:
850: pFEA->cbValue += usDelta; /* Adjust struct len field */
851:
852: return(FILE_CHANGED = TRUE);
853: }
854:
855: FreeMem(pFEA->aValue); /* Free up old value */
856: }
857: GetMem((PPVOID)&szNew, strlen(szScratch)+4); /* Get space for new value */
858: pusPtr = (USHORT *) szNew;
859: *pusPtr= usEAType; /* Set type field */
860: pusPtr++;
861: *pusPtr= strlen(szScratch); /* Set length field */
862: memcpy(szNew+4,szScratch,*pusPtr); /* Copy in new value */
863: pFEA->aValue = szNew; /* Adjust pointers */
864: pFEA->cbValue= strlen(szScratch)+4; /* +4 for type and LP cnt */
865:
866: return(FILE_CHANGED = TRUE);
867:
868: case EA_MVMT: /* It's multi-value multi-type */
869: if(pFEA->cbValue == 0) /* It's a new EA */
870: {
871: GetMem((PPVOID)&pFEA->aValue, 3*sizeof(USHORT)); /* Allocate empty m-m EA */
872: pFEA->cbValue = 3*sizeof(USHORT);
873: pusPtr = (USHORT *) pFEA->aValue;
874: *pusPtr = 0xffdf; /* Multi-value, multi-type */
875: pusPtr+=2; /* Skip type, codepage */
876: *pusPtr = 0; /* No fields initially */
877: FILE_CHANGED = TRUE;
878: }
879:
880: /* Set up passed in data */
881: if(pPDat->cbMulti) /* It's a multi-type job */
882: {
883: szNew = MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
884: pPDat->usIndex);
885: szTrash = MultiTypeIndex(pFEA->aValue + pPDat->usMultiOffset,
886: pPDat->usIndex+1);
887: PDat.usMultiOffset = szNew - pFEA->aValue;
888: PDat.cbMulti = szTrash - szNew;
889: }
890: else
891: {
892: PDat.usMultiOffset = 0;
893: PDat.cbMulti = pFEA->cbValue;
894: }
895: PDat.Point = (CHAR *) pFEA;
896:
897: WinDlgBox(HWND_DESKTOP, /* Do the Multi-type edit */
898: hwnd,
899: MultiTypeProc,
900: NULL,
901: IDD_MULTIBOX,
902: &PDat);
903: return(TRUE);
904:
905: }
906: }
907:
908:
909: /*
910: * Function name: EAExists()
911: *
912: * Parameters: szEAName points to the EA Name to check for.
913: *
914: * Returns: TRUE iff an EA with a name matching szEAName exists.
915: *
916: * Purpose: This routine goes through the linked list pointed to by global
917: * pHoldFEA and determines whether or not an EA of the passed name
918: * already exists.
919: *
920: * Usage/Warnings: The comparison is NOT case sensitive.
921: *
922: * Calls:
923: *
924: */
925:
926: BOOL EAExists(CHAR *szEAName)
927: {
928: HOLDFEA *phFEA=pHoldFEA;
929:
930: while(phFEA)
931: {
932: if(!stricmp(szEAName,phFEA->szName))
933: return(TRUE);
934: phFEA=phFEA->next;
935: }
936: return(FALSE);
937: }
938:
939:
940: /*
941: * Function name: ChangeName()
942: *
943: * Parameters: hwnd is the current window used for error messages.
944: * pFEA points to the current FEA.
945: * szName points to the new EA name.
946: *
947: * Returns: VOID. Fixes up the pFEA structure and global pDelList.
948: *
949: * Purpose: This routine copies the current EA Name to the delete list, then
950: * allocates a new space, copies the new name into it, and sets the
951: * FEA pointer to it.
952: *
953: * Usage/Warnings: NOTE: Not all the memory allocations are fully error
954: * trapped.
955: *
956: * Calls:
957: *
958: */
959:
960: VOID ChangeName(HOLDFEA *pFEA,CHAR *szName)
961: {
962: CHAR *szTemp;
963: DELETELIST *pDL;
964:
965: GetMem((PPVOID)&szTemp, strlen(szName+1)); /* Allocate space for new name */
966: if(!szTemp)
967: return;
968:
969: GetMem((PPVOID)&pDL, (USHORT) sizeof(DELETELIST)); /* Allocate a new delete struct */
970: pDL->EAName = pFEA->szName; /* Fill in DeleteList struct */
971: pDL->next = pDelList;
972: pDelList = pDL;
973:
974: strcpy(szTemp,szName); /* Copy name to permanent buffer */
975: pFEA->szName = szTemp; /* Fix up struct */
976: pFEA->cbName = (CHAR) strlen(szName);
977:
978: FILE_CHANGED = TRUE;
979: }
980:
981:
982: /*
983: * Function name: MultiTypeIndex()
984: *
985: * Parameters: pMulti points to the current m-m field.
986: * usIndex is the field the caller is interested in.
987: *
988: * Returns: a pointer to the field specified by the usIndex param.
989: *
990: * Purpose: This routine takes a pointer to a Multi-Multi data field and
991: * returns a pointer to the nth data field in this buffer.
992: *
993: * Usage/Warnings: NOTE: Memory bounds are not checked and a corrupt
994: * EA field could cause unspecified results.
995: * Recursively calls itself to handle nesting. Does not
996: * support multi-value single type fields.
997: *
998: * Calls: LookupEAType, MultiTypeIndex()
999: *
1000: */
1001:
1002: CHAR *MultiTypeIndex(CHAR *pMulti, USHORT usIndex)
1003: {
1004: USHORT *pusPtr;
1005: USHORT usOffset;
1006:
1007: pMulti += 3*sizeof(USHORT); /* skip over 0xffdf, codepage, and field cnt */
1008:
1009: while(usIndex--) /* loop to skip over correct # of flds */
1010: {
1011: pusPtr = (USHORT *) pMulti;
1012: usOffset = LookupEAType(*pusPtr); /* Get offset of field type */
1013:
1014: pMulti += sizeof(USHORT); /* Skip over the type field */
1015:
1016: switch(ConvTable[usOffset].usFldType)
1017: {
1018: case IDD_ASCIIZ:
1019: while(*pMulti++); /* Increment to point after NULL */
1020: break;
1021:
1022: case IDD_LPDATA:
1023: pusPtr = (USHORT *) pMulti; /* Get the length */
1024: pMulti += *pusPtr + sizeof(USHORT); /* skip to end */
1025: break;
1026:
1027: case IDD_MULTILIST:
1028: if(*pusPtr == EA_MVMT) /* m-m, do a recursive call to skip fld */
1029: {
1030: pusPtr = (USHORT *) pMulti; /* points to field cnt */
1031: pMulti = MultiTypeIndex(pMulti-sizeof(USHORT),*pusPtr);
1032: break;
1033: }
1034: /* Not yet implemented for Multi-valued single-type stuff... */
1035: break;
1036: }
1037: }
1038: return(pMulti);
1039: }
1040:
1041:
1042: /*
1043: * Function name: EAValueString()
1044: *
1045: * Parameters: hwnd is the current window handle.
1046: * aEAVal is a pointer to an EA value field.
1047: *
1048: * Returns: a pointer to an ASCII description of the field value.
1049: *
1050: * Purpose: This routine takes a pointer to an EA Value (i.e. starting with
1051: * with $ffxx) and returns a pointer to a string representing the
1052: * value of the EA. This string must be Freed by the user when
1053: * finished with it.
1054: *
1055: * Usage/Warnings: NOTE: Not all GetMem's are totally error trapped.
1056: * The string returned is allocated in this procedure,
1057: * but it is the caller's responsibility to free the buffer.
1058: *
1059: * Calls:
1060: *
1061: */
1062:
1063: CHAR *EAValueString(CHAR *aEAVal)
1064: {
1065: USHORT *pusPtr= (USHORT *) aEAVal; /* Points to EA Type */
1066: CHAR *szRet,*szTemp; /* szRet points to return string */
1067:
1068: switch(*pusPtr)
1069: {
1070: case EA_ASCIIZ: /* For asciiz strings, return MAXSHOWSIZE-1 chars */
1071: case EA_ASCIIZFN:
1072: case EA_ASCIIZEA:
1073: case EA_ASN1:
1074: aEAVal += sizeof(USHORT);
1075: if(strlen(aEAVal)<MAXSHOWSIZE)
1076: {
1077: GetMem((PPVOID)&szRet, strlen(aEAVal)+1);
1078: strcpy(szRet,aEAVal);
1079: }
1080: else
1081: {
1082: GetMem((PPVOID)&szRet, MAXSHOWSIZE);
1083: strncpy(szRet,aEAVal,MAXSHOWSIZE-4);
1084: strcpy (szRet+MAXSHOWSIZE-4,"...");
1085: szRet[MAXSHOWSIZE-1]=NULL;
1086: }
1087: return(szRet);
1088:
1089: case EA_LPASCII: /* Display up to first MAXSHOWSIZE-1 chars */
1090: case EA_LPMETAFILE:
1091: pusPtr++;
1092: aEAVal += 2*sizeof(USHORT);
1093: if(*pusPtr < MAXSHOWSIZE)
1094: {
1095: GetMem((PPVOID)&szRet, *pusPtr +1);
1096: strncpy(szRet,aEAVal,*pusPtr);
1097: szRet[*pusPtr]=NULL;
1098: }
1099: else
1100: {
1101: GetMem((PPVOID)&szRet, MAXSHOWSIZE);
1102: strncpy(szRet,aEAVal,MAXSHOWSIZE-4);
1103: strcpy (szRet+MAXSHOWSIZE-4,"...");
1104: szRet[MAXSHOWSIZE-1]=NULL;
1105: }
1106: return(szRet);
1107:
1108: /* For the rest of the types, just display the field type */
1109:
1110: case EA_LPBINARY:
1111: szTemp = "*** LP Binary ***";
1112: break;
1113:
1114: case EA_LPBITMAP:
1115: szTemp = "*** LP Bitmap ***";
1116: break;
1117:
1118: case EA_LPICON:
1119: szTemp = "*** LP Icon ***";
1120: break;
1121:
1122: case EA_MVMT:
1123: szTemp = "*** Multi-value Multi-type ***";
1124: break;
1125:
1126: case EA_MVST:
1127: szTemp = "*** Multi-value Single-type ***";
1128: break;
1129:
1130: default:
1131: szTemp = "*** Unknown EA type ***";
1132: break;
1133:
1134: }
1135: GetMem((PPVOID)&szRet, strlen(szTemp)+1); /* Copy string from static to dynamic */
1136: strcpy(szRet,szTemp);
1137: return(szRet);
1138: }
1139:
1140:
1141: /*
1142: * Function name: MultiAdd()
1143: *
1144: * Parameters: hwnd is the current window handle.
1145: * pFEA points to the current FEA.
1146: * pPDat gives the current m-m data.
1147: *
1148: * Returns: VOID. Modifies the current pFEA.
1149: *
1150: * Purpose: This routine is called by MultiTypeProc and handles the addition
1151: * of a subvalue to a multi-value, multi-type EA.
1152: *
1153: * Usage/Warnings: NOTE: Not all GetMem's are totally error trapped.
1154: * It is also possible that the add to the listbox could fail.
1155: *
1156: * Calls: AddEAProc() (thru PM), MultiTypeIndex()
1157: *
1158: */
1159:
1160: VOID MultiAdd(HWND hwnd, HOLDFEA *pFEA,PASSDATA FAR *pPDat)
1161: {
1162: USHORT usSize;
1163: USHORT *pusPtr;
1164: CHAR aUtility[6]; /* Used to hold the header for all EA types */
1165: CHAR *pInsert,*pValue;
1166: PASSDATA PDat;
1167:
1168: PDat.Point = pFEA->szName;
1169:
1170: if(!WinDlgBox(HWND_DESKTOP, /* Get the name and type */
1171: hwnd,
1172: AddEAProc,
1173: NULL,
1174: IDD_ADDEA,
1175: &PDat))
1176: return; /* They said cancel */
1177:
1178: pusPtr = (USHORT *) aUtility;
1179: *pusPtr= ConvTable[usRetEAType].usPrefix; /* Set the type in header buf */
1180:
1181: switch(ConvTable[usRetEAType].usFldType)
1182: {
1183: case IDD_ASCIIZ: /* make buffer look like: xx FF 00, size 3 */
1184: usSize = 3;
1185: aUtility[2]=0;
1186: break;
1187:
1188: case IDD_LPDATA: /* make the buffer look like: xx FF 00 00, size 4 */
1189: usSize = 4;
1190: pusPtr = (USHORT *) &aUtility[2];
1191: *pusPtr= 0;
1192: break;
1193:
1194: case IDD_MULTILIST:
1195: usSize = 6;
1196: pusPtr = (USHORT *) &aUtility[2];
1197: *pusPtr= 0; /* Zero out codepage */
1198: pusPtr++;
1199: *pusPtr= 0; /* Zero out fld cnt */
1200: break;
1201: }
1202: /* Increase EA size to accomodate the header */
1203: ResizeMem(pFEA->aValue, pFEA->cbValue, pFEA->cbValue+usSize);
1204:
1205: pusPtr = (USHORT *) ((CHAR *) pFEA->aValue + pPDat->usMultiOffset);
1206: pusPtr+=2; /* Point to the current number of m-m fields */
1207:
1208: /* Get ptr to beginning of current EA, scoot the rest down and insert
1209: the 3-4 byte header at the end of the list. */
1210: pInsert = MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset, *pusPtr);
1211: memmove(pInsert+usSize,pInsert, pFEA->cbValue-(pInsert-pFEA->aValue));
1212: memcpy(pInsert,aUtility,usSize);
1213:
1214: pFEA->cbValue += usSize; /* Fix up the counts */
1215: pPDat->cbMulti+= usSize;
1216: /* Set the PDat for call */
1217: PDat.Point = (CHAR *) pFEA;
1218: PDat.cbMulti = pPDat->cbMulti;
1219: PDat.usMultiOffset = pPDat->usMultiOffset;
1220: PDat.usIndex = *pusPtr;
1221:
1222: if(!EditEAValue(hwnd,&PDat)) /* They canceled the edit */
1223: { /* Move the EA's back to effectively kill the inserted header */
1224: memmove(pInsert,pInsert+usSize,pFEA->cbValue-(pInsert-pFEA->aValue));
1225: DosSetMem(pFEA->aValue, pFEA->cbValue-usSize, fPERM|PAG_COMMIT);
1226: pFEA->cbValue -= usSize; /* Adjust counters */
1227: pPDat->cbMulti-= usSize;
1228:
1229: return;
1230: }
1231:
1232: /* Reset pusPtr since EditEAValue could have moved the base address */
1233: pusPtr = (USHORT *) ((CHAR *) pFEA->aValue + pPDat->usMultiOffset);
1234: pusPtr+=2;
1235:
1236: pInsert = MultiTypeIndex(pFEA->aValue+pPDat->usMultiOffset, *pusPtr);
1237:
1238: *pusPtr += 1; /* Field cnt incremented AFTER call to Edit */
1239:
1240: pValue = EAValueString(pInsert); /* Add new field to the list box */
1241:
1242: WinSendDlgItemMsg(hwnd, IDD_LBOX, LM_INSERTITEM,
1243: MPFROM2SHORT(LIT_END,0),
1244: MPFROMP(pValue));
1245: FreeMem(pValue);
1246:
1247: FILE_CHANGED = TRUE;
1248: }
1249:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.