source: trunk/dll/eas.c@ 284

Last change on this file since 284 was 207, checked in by root, 20 years ago

Drop unused variables
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 35.8 KB
RevLine 
[123]1
2/***********************************************************************
3
4 $Id: eas.c 207 2005-06-08 06:00:32Z root $
5
6 Copyright (c) 1993-98 M. Kimes
[193]7 Copyright (c) 2004, 2005 Steven H. Levine
[123]8
[193]9 01 Aug 04 SHL Rework lstrip/rstrip usage
10 06 Jun 05 SHL Indent -i2
[207]11 06 Jun 05 SHL Rework DisplayEAsProc for VAC3.65 compat
12 06 Jun 05 SHL Drop unused variables
[123]13
14***********************************************************************/
15
[2]16#define INCL_WIN
17#define INCL_DOS
18#define INCL_DOSERRORS
[193]19#include <os2.h>
[2]20
21#include <stdlib.h>
22#include <stdio.h>
23#include <string.h>
24#include <ctype.h>
[193]25
[2]26#include "fm3dll.h"
27#include "fm3dlg.h"
28#include "fm3str.h"
29#include "mle.h"
30
31#pragma data_seg(DATA1)
32#pragma alloc_text(EAS,DisplayEAsProc,SaveEA,HexDumpEA,CheckEA,AddEAProc)
33#pragma alloc_text(EAS1,HexDump,GetFileEAs,Free_FEAList)
34
[193]35typedef struct
36{
[2]37 CHAR *name;
[193]38 INT type;
39}
40RESERVEDEAS;
[2]41
[193]42typedef struct
43{
44 CHAR *filename;
[2]45 HOLDFEA *head;
[193]46}
47ADDEA;
[2]48
[193]49HOLDFEA *CheckEA(HOLDFEA * head, CHAR * eaname)
50{
[2]51 /* return pointer to ea named eaname if found in linked list */
52
53 register HOLDFEA *info = NULL;
54
[193]55 if (eaname && *eaname)
56 {
[2]57 info = head;
[193]58 while (info)
59 {
60 if (!strcmp(info -> name, eaname))
61 return info;
62 info = info -> next;
[2]63 }
64 }
65 return info;
66}
67
[193]68MRESULT EXPENTRY AddEAProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
69{
70 ADDEA *add;
71 HOLDFEA *head;
72 CHAR *filename;
73 static CHAR *forbidden[] =
74 {".ASSOCTABLE",
75 ".CLASSINFO",
76 ".ICON",
77 ".CODEPAGE",
78 ""};
79 static RESERVEDEAS restypes[] =
80 {".TYPE", EAT_MVMT,
81 ".SUBJECT", EAT_ASCII,
82 ".COMMENTS", EAT_MVMT,
83 ".KEYPHRASES", EAT_MVMT,
84 ".HISTORY", EAT_MVMT,
85 ".LONGNAME", EAT_ASCII,
86 ".VERSION", EAT_ASCII,
87 "", 0};
[2]88
[193]89 switch (msg)
90 {
91 case WM_INITDLG:
92 if (!mp2)
93 {
94 WinDismissDlg(hwnd, 0);
[2]95 break;
[193]96 }
97 WinSetWindowPtr(hwnd, 0, (PVOID) mp2);
98 WinSendDlgItemMsg(hwnd, EAC_NAME, EM_SETTEXTLIMIT,
99 MPFROM2SHORT(255, 0), MPVOID);
100 WinCheckButton(hwnd, EAC_ASCII, TRUE);
101 break;
[2]102
[193]103 case WM_PAINT:
104 PostMsg(hwnd, UM_PAINT, MPVOID, MPVOID);
105 break;
[2]106
[193]107 case UM_PAINT:
108 PaintRecessedWindow(WinWindowFromID(hwnd, EAC_TEXT), (HPS) 0, FALSE, FALSE);
109 return 0;
[2]110
[193]111 case WM_CONTROL:
112 return 0;
[2]113
[193]114 case WM_COMMAND:
115 switch (SHORT1FROMMP(mp1))
116 {
117 case DID_OK:
118 add = INSTDATA(hwnd);
119 head = add -> head;
120 filename = add -> filename;
121 {
122 CHAR s[257];
123 INT x;
124 USHORT type = EAT_ASCII;
[2]125
[193]126 *s = 0;
127 WinQueryDlgItemText(hwnd, EAC_NAME, 255, s);
128 bstrip(s);
129 if (!*s)
130 WinDismissDlg(hwnd, 0);
131 else
132 {
133 if (CheckEA(head, s))
134 {
135 DosBeep(50, 100);
136 WinSetDlgItemText(hwnd, EAC_TEXT,
137 GetPString(IDS_EANAMEEXISTSTEXT));
138 break;
139 }
140 for (x = 0; *forbidden[x]; x++)
141 {
142 if (!strcmp(forbidden[x], s))
143 {
144 DosBeep(50, 100);
145 WinSetDlgItemText(hwnd, EAC_TEXT,
146 GetPString(IDS_EANAMERESERVEDTEXT));
147 return 0;
148 }
149 }
150 if (WinQueryButtonCheckstate(hwnd, EAC_MVST))
151 type = EAT_MVST;
152 else if (WinQueryButtonCheckstate(hwnd, EAC_MVMT))
153 type = EAT_MVMT;
154 for (x = 0; *restypes[x].name; x++)
155 {
156 if (!strcmp(restypes[x].name, s))
157 {
158 if (type != restypes[x].type)
159 {
160 DosBeep(50, 100);
161 WinSetDlgItemText(hwnd, EAC_TEXT,
162 GetPString(IDS_EAWRONGTYPETEXT));
163 return 0;
164 }
165 break;
166 }
167 }
168 /* if we get here, create dummy ea */
169 {
170 PFEA2LIST pfealist = NULL;
171 EAOP2 eaop;
172 ULONG ealen;
173 CHAR *eaval;
[2]174
[193]175 ealen = sizeof(FEA2LIST) + strlen(s) + 64;
176 if (!DosAllocMem((PPVOID) & pfealist, ealen + 1L,
177 OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE))
178 {
179 memset(pfealist, 0, ealen + 1);
180 pfealist -> cbList = ealen;
181 pfealist -> list[0].oNextEntryOffset = 0L;
182 pfealist -> list[0].fEA = 0;
183 pfealist -> list[0].cbName = strlen(s);
184 strcpy(pfealist -> list[0].szName, s);
185 eaval = pfealist -> list[0].szName + strlen(s) + 1;
186 *(USHORT *) eaval = (USHORT) type;
187 eaval += sizeof(USHORT);
188 if (type == EAT_MVST || type == EAT_MVMT)
189 {
190 *(USHORT *) eaval = (USHORT) 0; /* codepage */
191 eaval += sizeof(USHORT);
192 *(USHORT *) eaval = (USHORT) 1; /* number */
193 eaval += sizeof(USHORT);
194 *(USHORT *) eaval = (USHORT) EAT_ASCII; /* type */
195 eaval += sizeof(USHORT);
196 }
197 *(USHORT *) eaval = (USHORT) 4;
198 eaval += sizeof(USHORT);
199 memcpy(eaval, GetPString(IDS_FAKETEXT), 4);
200 pfealist -> list[0].cbValue = 4 + (sizeof(USHORT) * 2) +
201 ((type == EAT_MVST ||
202 type == EAT_MVMT) ?
203 sizeof(USHORT) * 3 : 0);
204 eaop.fpGEA2List = (PGEA2LIST) 0;
205 eaop.fpFEA2List = pfealist;
206 eaop.oError = 0L;
207 DosSetPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & eaop,
208 (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
209 WinDismissDlg(hwnd, 1);
210 }
211 }
212 }
213 }
214 break;
[2]215
[193]216 case DID_CANCEL:
217 WinDismissDlg(hwnd, 0);
218 break;
[2]219
[193]220 case IDM_HELP:
221 if (hwndHelp)
222 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
223 MPFROM2SHORT(HELP_ADDEA, 0),
224 MPFROMSHORT(HM_RESOURCEID));
225 break;
226 }
227 return 0;
[2]228 }
[193]229 return WinDefDlgProc(hwnd, msg, mp1, mp2);
[2]230}
231
[193]232static VOID HexDumpEA(HWND hwnd, HOLDFEA * info)
233{
234 if (info)
235 HexDump(WinWindowFromID(hwnd, EA_HEXDUMP), info -> value, info -> cbValue);
[2]236}
237
[193]238VOID HexDump(HWND hwnd, CHAR * value, ULONG cbValue)
239{
[2]240 /* display a hexdump of a binary 'string' in listbox hwnd */
241
[193]242 CHAR s[132];
243 register CHAR *p, *pp, *a;
244 register ULONG x = 0, y, z;
[2]245
[193]246 WinSendMsg(hwnd, LM_DELETEALL, MPVOID, MPVOID);
247 if (cbValue)
248 {
[2]249 pp = p = value;
[193]250 while (x < cbValue)
251 {
[2]252 y = x;
[193]253 sprintf(s, "%04lx ", x);
[2]254 a = s + 6;
[193]255 do
256 {
257 sprintf(a, "%02hx ", *p);
258 a += 3;
259 p++;
260 x++;
[2]261 }
[193]262 while (x < cbValue && (x % 16));
263 if (x % 16)
264 {
265 z = x;
266 while (z % 16)
267 {
268 *a++ = ' ';
269 *a++ = ' ';
270 *a++ = ' ';
271 z++;
272 }
273 }
[2]274 *a++ = ' ';
275 p = pp;
[193]276 do
277 {
278 if (*p)
279 *a++ = *p++;
280 else
281 {
282 *a++ = '.';
283 p++;
284 }
285 *a = 0;
286 y++;
287 }
288 while (y < x);
289 if ((SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
290 MPFROMP(s)) < 0)
291 break;
[2]292 pp = p;
293 }
294 }
295}
296
[193]297typedef struct
298{
299 USHORT size;
300 USHORT flags;
301 HOLDFEA *head, *current;
302 CHAR **list;
303 CHAR filename[CCHMAXPATH];
304}
305EAPROCDATA;
[2]306
[193]307MRESULT EXPENTRY DisplayEAsProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
308{
309 EAPROCDATA *eap;
310 HOLDFEA *info;
311 static HPOINTER hptrIcon = (HPOINTER) 0;
[2]312
[193]313 if (msg != WM_INITDLG)
314 eap = (EAPROCDATA *) WinQueryWindowPtr(hwnd, 0);
[2]315
[193]316 switch (msg)
317 {
318 case WM_INITDLG:
319 if (!mp2)
320 {
321 WinDismissDlg(hwnd, 0);
322 break;
323 }
324 eap = malloc(sizeof(EAPROCDATA));
325 if (!eap)
326 {
327 WinDismissDlg(hwnd, 0);
328 break;
329 }
330 hptrIcon = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, EA_FRAME);
331 WinDefDlgProc(hwnd, WM_SETICON, MPFROMLONG(hptrIcon), MPVOID);
332 memset(eap, 0, sizeof(EAPROCDATA));
333 eap -> size = sizeof(EAPROCDATA);
334 eap -> list = (CHAR **) mp2;
335 WinSetWindowPtr(hwnd, 0, (PVOID) eap);
336 WinSendDlgItemMsg(hwnd,
337 EA_ENTRY,
338 EM_SETTEXTLIMIT,
339 MPFROM2SHORT(40, 0),
340 MPVOID);
341 MLEsetlimit(WinWindowFromID(hwnd, EA_MLE),
342 32767L);
343 MLEsetformat(WinWindowFromID(hwnd, EA_MLE),
344 MLFIE_NOTRANS);
345 {
346 INT x;
347 SHORT sSelect;
348 CHAR s[CCHMAXPATH];
[2]349
[193]350 for (x = 0; eap -> list[x]; x++)
351 {
352 if (DosQueryPathInfo(eap -> list[x],
353 FIL_QUERYFULLNAME,
354 s,
355 sizeof(s)))
356 strcpy(s, eap -> list[x]);
357 if (IsFile(s) != -1)
358 WinSendDlgItemMsg(hwnd,
359 EA_NAMES,
360 LM_INSERTITEM,
361 MPFROM2SHORT(LIT_SORTASCENDING, 0),
362 MPFROMP(s));
363 }
364 sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
365 EA_NAMES,
366 LM_QUERYITEMCOUNT,
367 MPVOID,
368 MPVOID);
369 if (sSelect > 0)
370 WinSendDlgItemMsg(hwnd,
371 EA_NAMES,
372 LM_SELECTITEM,
373 MPFROM2SHORT(0, 0),
374 MPFROMSHORT(TRUE));
375 else
376 WinDismissDlg(hwnd, 0);
377 }
378 break;
[2]379
[193]380 case UM_SETDIR:
381 if (*eap -> filename)
382 {
383 if (eap -> head)
384 Free_FEAList(eap -> head);
385 eap -> head = GetFileEAs(eap -> filename,
386 FALSE,
387 FALSE);
388 if (!isalpha(*eap -> filename) ||
389 (driveflags[toupper(*eap -> filename) - 'A'] & DRIVE_NOTWRITEABLE))
390 {
391 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
392 WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
393 WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
[2]394 }
[193]395 else
396 {
397 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
398 WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
399 WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
[2]400 }
[193]401 WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
402 }
403 break;
404
405 case UM_SETUP:
406 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
407 WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
408 WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
409 WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
410 MLEclearall(WinWindowFromID(hwnd, EA_MLE));
411 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
412 WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
413 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
414 WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
415 eap -> current = NULL;
416 if (eap -> head)
417 {
418 WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
419 info = eap -> head;
420 while (info)
[2]421 {
[193]422 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_INSERTITEM,
423 MPFROM2SHORT(LIT_END, 0),
424 MPFROMP(info -> name));
425 info = info -> next;
[2]426 }
[193]427 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
428 MPFROM2SHORT(0, 0), MPFROM2SHORT(TRUE, 0));
429 }
430 else
431 WinSetDlgItemText(hwnd, EA_TEXT,
432 GetPString(IDS_EANOEAS));
433 return 0;
[2]434
[193]435 case WM_PAINT:
436 PostMsg(hwnd, UM_PAINT, MPVOID, MPVOID);
437 break;
[2]438
[193]439 case UM_PAINT:
440 PaintRecessedWindow(WinWindowFromID(hwnd, EA_HELP), (HPS) 0, FALSE, TRUE);
441 PaintRecessedWindow(WinWindowFromID(hwnd, EA_TEXT), (HPS) 0, FALSE, FALSE);
442 return 0;
[2]443
[193]444 case WM_CONTROL:
445 switch (SHORT1FROMMP(mp1))
446 {
447 case EA_NAMES:
448 switch (SHORT2FROMMP(mp1))
449 {
450 case LN_SETFOCUS:
451 WinSetDlgItemText(hwnd, EA_HELP,
452 GetPString(IDS_EAFILENAMESHELPTEXT));
453 break;
454 case LN_KILLFOCUS:
455 WinSetDlgItemText(hwnd, EA_HELP, NullStr);
456 break;
457 case LN_ENTER:
458 case LN_SELECT:
459 {
460 CHAR s[CCHMAXPATH];
461 SHORT sSelect;
462
463 sSelect = (SHORT) WinSendDlgItemMsg(hwnd, EA_NAMES,
464 LM_QUERYSELECTION,
465 MPFROM2SHORT(LIT_FIRST, 0),
466 MPVOID);
467 if (sSelect >= 0)
468 {
469 *s = 0;
470 WinSendDlgItemMsg(hwnd, EA_NAMES, LM_QUERYITEMTEXT,
471 MPFROM2SHORT(sSelect, CCHMAXPATH),
472 MPFROMP(s));
473 if (*s)
474 {
475 strcpy(eap -> filename, s);
476 if (SHORT2FROMMP(mp1) == LN_SELECT)
477 WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
478 else
479 QuickView(hwnd, eap -> filename);
480 }
481 }
482 }
483 break;
[2]484 }
485 break;
486
[193]487 case EA_LISTBOX:
488 switch (SHORT2FROMMP(mp1))
489 {
490 case LN_SETFOCUS:
491 WinSetDlgItemText(hwnd, EA_HELP,
492 GetPString(IDS_EATYPESHELPTEXT));
493 break;
494 case LN_KILLFOCUS:
495 WinSetDlgItemText(hwnd, EA_HELP, NullStr);
496 break;
497 case LN_SELECT:
498 {
499 CHAR s[257];
500 SHORT sSelect;
[2]501
[193]502 eap -> current = NULL;
503 if (eap -> head)
504 {
505 WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
506 WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
507 WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
508 MLEclearall(WinWindowFromID(hwnd, EA_MLE));
509 WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
510 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
511 WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
512 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
513 WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL,
514 MPVOID, MPVOID);
515 *s = 0;
516 sSelect = (USHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
517 LM_QUERYSELECTION, MPFROMSHORT(LIT_FIRST),
518 MPVOID);
519 if (sSelect >= 0)
520 {
521 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_QUERYITEMTEXT,
522 MPFROM2SHORT(sSelect, 256),
523 MPFROMP(s));
524 if (*s)
525 {
[2]526
[207]527 USHORT len, num, type;
528 CHAR *data;
529 CHAR last = '\n';
530 const CHAR *linefeed = "\n";
[193]531 BOOL alltext;
532 IPT pos = 0L;
[2]533
[193]534 info = eap -> head;
535 while (info)
536 {
537 if (!strcmp(s, info -> name))
538 {
539 eap -> current = info;
540 WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
541 switch (*(USHORT *) info -> value)
542 {
543 case EAT_EA:
544 case EAT_ASCII:
545 if (!strcmp(info -> name, SUBJECT))
546 WinSendDlgItemMsg(hwnd, EA_ENTRY,
547 EM_SETTEXTLIMIT,
548 MPFROM2SHORT(40, 0), MPVOID);
549 else
550 WinSendDlgItemMsg(hwnd, EA_ENTRY,
551 EM_SETTEXTLIMIT,
552 MPFROM2SHORT(256, 0), MPVOID);
553 WinSetDlgItemText(hwnd, EA_ENTRY,
554 info -> value +
555 (sizeof(USHORT) * 2));
556 WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY),
557 TRUE);
558 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
559 FALSE);
560 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE),
561 TRUE);
562 {
563 CHAR str[81];
[2]564
[193]565 sprintf(str,
566 GetPString(IDS_DATAANDBYTESTEXT),
567 (*(USHORT *) info -> value == EAT_ASCII) ?
568 GetPString(IDS_TEXTTEXT) :
569 GetPString(IDS_EAREFTEXT),
570 info -> cbValue);
571 WinSetDlgItemText(hwnd,
572 EA_TEXT,
573 str);
574 }
575 break;
576 case EAT_MVST:
577 MLEclearall(WinWindowFromID(hwnd, EA_MLE));
578 num = *(USHORT *) (info -> value +
579 (sizeof(USHORT) * 2));
580 type = *(USHORT *) (info -> value +
581 (sizeof(USHORT) * 3));
582 if (type == EAT_ASCII)
583 {
584 data = info -> value + (sizeof(USHORT) * 4);
585 len = *(USHORT *) data;
586 data += sizeof(USHORT);
587 while ((data - info -> value) + len <=
588 info -> cbValue)
589 {
590 if (last != '\n')
591 {
592 WinSendDlgItemMsg(hwnd,
593 EA_MLE,
594 MLM_SETIMPORTEXPORT,
595 MPFROMP(linefeed),
596 MPFROMLONG(1L));
597 WinSendDlgItemMsg(hwnd,
598 EA_MLE,
599 MLM_IMPORT,
600 MPFROMP(&pos),
601 MPFROMLONG(1L));
602 }
603 WinSendDlgItemMsg(hwnd,
604 EA_MLE,
605 MLM_SETIMPORTEXPORT,
606 MPFROMP(data),
607 MPFROMLONG((ULONG) len));
608 WinSendDlgItemMsg(hwnd,
609 EA_MLE,
610 MLM_IMPORT,
611 MPFROMP(&pos),
612 MPFROMLONG((ULONG) len));
613 data += len;
614 last = *(data - 1);
615 if (data - info -> value >= info -> cbValue)
616 break;
617 len = *(USHORT *) data;
618 data += sizeof(USHORT);
619 }
620 WinShowWindow(WinWindowFromID(hwnd, EA_MLE),
621 TRUE);
622 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
623 FALSE);
624 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE),
625 TRUE);
626 }
627 else
628 {
629 WinShowWindow(WinWindowFromID(hwnd, EA_MLE),
630 FALSE);
631 HexDumpEA(hwnd, info);
632 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
633 TRUE);
634 }
635 {
636 CHAR str[81];
[2]637
[193]638 sprintf(str,
639 GetPString(IDS_MVSTTEXT),
640 num,
641 (num == 1) ?
642 GetPString(IDS_YTEXT) :
643 GetPString(IDS_IESTEXT),
644 info -> cbValue);
645 WinSetDlgItemText(hwnd,
646 EA_TEXT,
647 str);
648 }
649 break;
650 case EAT_MVMT:
651 MLEclearall(WinWindowFromID(hwnd, EA_MLE));
652 num = *(USHORT *) (info -> value +
653 (sizeof(USHORT) * 2));
654 data = info -> value + (sizeof(USHORT) * 3);
655 type = *(USHORT *) data;
656 data += sizeof(USHORT);
657 len = *(USHORT *) data;
658 data += sizeof(USHORT);
659 alltext = TRUE;
660 while ((data - info -> value) - len <=
661 info -> cbValue)
662 {
663 if (type != EAT_ASCII)
664 {
665 alltext = FALSE;
666 break;
667 }
668 data += len;
669 if (data - info -> value >= info -> cbValue)
670 break;
671 type = *(USHORT *) data;
672 data += sizeof(USHORT);
673 len = *(USHORT *) data;
674 data += sizeof(USHORT);
675 }
676 if (alltext)
677 {
678 data = info -> value + (sizeof(USHORT) * 3);
679 type = *(USHORT *) data;
680 data += sizeof(USHORT);
681 len = *(USHORT *) data;
682 data += sizeof(USHORT);
683 while ((data - info -> value) - len <=
684 info -> cbValue)
685 {
686 if (last != '\n')
687 {
688 WinSendDlgItemMsg(hwnd,
689 EA_MLE,
690 MLM_SETIMPORTEXPORT,
691 MPFROMP(linefeed),
692 MPFROMLONG(1L));
693 WinSendDlgItemMsg(hwnd,
694 EA_MLE,
695 MLM_IMPORT,
696 MPFROMP(&pos),
697 MPFROMLONG(1L));
698 }
699 WinSendDlgItemMsg(hwnd,
700 EA_MLE,
701 MLM_SETIMPORTEXPORT,
702 MPFROMP(data),
703 MPFROMLONG((ULONG) len));
704 WinSendDlgItemMsg(hwnd,
705 EA_MLE,
706 MLM_IMPORT,
707 MPFROMP(&pos),
708 MPFROMLONG((ULONG) len));
709 data += len;
710 last = *(data - 1);
711 if (data - info -> value >= info -> cbValue)
712 break;
713 type = *(USHORT *) data;
714 data += sizeof(USHORT);
715 len = *(USHORT *) data;
716 data += sizeof(USHORT);
717 }
718 }
719 if (alltext)
720 {
721 WinShowWindow(WinWindowFromID(hwnd, EA_MLE),
722 TRUE);
723 WinEnableWindow(WinWindowFromID(hwnd,
724 EA_CHANGE), FALSE);
725 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE),
726 TRUE);
727 }
728 else
729 {
730 WinShowWindow(WinWindowFromID(hwnd, EA_MLE),
731 FALSE);
732 HexDumpEA(hwnd, info);
733 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
734 TRUE);
735 }
736 {
737 CHAR str[81];
[2]738
[193]739 sprintf(str,
740 GetPString(IDS_MVMTTEXT),
741 num,
742 (num == 1) ?
743 GetPString(IDS_YTEXT) :
744 GetPString(IDS_IESTEXT),
745 info -> cbValue,
746 (alltext) ?
747 GetPString(IDS_ALLTEXTTEXT) :
748 GetPString(IDS_MIXEDTYPESTEXT));
749 WinSetDlgItemText(hwnd,
750 EA_TEXT,
751 str);
752 }
753 break;
754 default:
755 HexDumpEA(hwnd, info);
756 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
757 TRUE);
758 switch (*(USHORT *) info -> value)
759 {
760 case EAT_BINARY:
761 {
762 CHAR str[81];
[2]763
[193]764 sprintf(str,
765 GetPString(IDS_BINARYBYTESTEXT),
766 info -> cbValue);
767 WinSetDlgItemText(hwnd,
768 EA_TEXT,
769 str);
770 }
771 break;
772 case EAT_BITMAP:
773 {
774 CHAR str[81];
[2]775
[193]776 sprintf(str,
777 GetPString(IDS_BITMAPBYTESTEXT),
778 info -> cbValue);
779 WinSetDlgItemText(hwnd,
780 EA_TEXT,
781 str);
782 }
783 break;
784 case EAT_METAFILE:
785 {
786 CHAR str[81];
[2]787
[193]788 sprintf(str,
789 GetPString(IDS_METAFILEBYTESTEXT),
790 info -> cbValue);
791 WinSetDlgItemText(hwnd,
792 EA_TEXT,
793 str);
794 }
795 break;
796 case EAT_ICON:
797 {
798 CHAR str[81];
[2]799
[193]800 sprintf(str,
801 GetPString(IDS_ICONBYTESTEXT),
802 info -> cbValue);
803 WinSetDlgItemText(hwnd,
804 EA_TEXT,
805 str);
806 }
807 break;
808 case EAT_ASN1:
809 {
810 CHAR str[81];
[2]811
[193]812 sprintf(str,
813 GetPString(IDS_ASN1BYTESTEXT),
814 info -> cbValue);
815 WinSetDlgItemText(hwnd,
816 EA_TEXT,
817 str);
818 }
819 break;
820 default:
821 {
822 CHAR str[81];
[2]823
[193]824 sprintf(str,
825 GetPString(IDS_UNKNOWNBYTESTEXT),
826 *(USHORT *) info -> value,
827 info -> cbValue);
828 WinSetDlgItemText(hwnd,
829 EA_TEXT,
830 str);
831 }
832 break;
833 }
834 break;
835 }
836 }
837 info = info -> next;
838 }
839 }
840 }
841 }
842 if (!isalpha(*eap -> filename) ||
843 (driveflags[toupper(*eap -> filename) - 'A'] & DRIVE_NOTWRITEABLE))
844 {
845 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
846 WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
847 WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
848 }
849 else
850 {
851 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
852 WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
853 WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
854 }
855 }
856 break;
857 }
858 break;
[2]859
[193]860 case EA_ENTRY:
861 switch (SHORT2FROMMP(mp1))
862 {
863 case EN_SETFOCUS:
864 WinSetDlgItemText(hwnd, EA_HELP,
865 GetPString(IDS_EADATAHELPTEXT));
866 break;
867 case EN_KILLFOCUS:
868 WinSetDlgItemText(hwnd, EA_HELP, NullStr);
869 break;
870 case EN_CHANGE:
871 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
872 break;
873 }
874 break;
[2]875
[193]876 case EA_HEXDUMP:
877 switch (SHORT2FROMMP(mp1))
878 {
879 case LN_SETFOCUS:
880 WinSetDlgItemText(hwnd, EA_HELP,
881 GetPString(IDS_EADATAHELPTEXT));
882 break;
883 case LN_KILLFOCUS:
884 WinSetDlgItemText(hwnd, EA_HELP, NullStr);
885 break;
886 }
887 break;
[2]888
[193]889 case EA_MLE:
890 switch (SHORT2FROMMP(mp1))
891 {
892 case MLN_SETFOCUS:
893 WinSetDlgItemText(hwnd, EA_HELP,
894 GetPString(IDS_EADATAHELPTEXT));
895 break;
896 case MLN_KILLFOCUS:
897 WinSetDlgItemText(hwnd, EA_HELP, NullStr);
898 break;
899 case MLN_CHANGE:
900 WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
901 break;
902 }
903 break;
904 }
905 return 0;
[2]906
[193]907 case WM_COMMAND:
908 switch (SHORT1FROMMP(mp1))
909 {
910 case EA_ADD:
911 {
912 ADDEA add;
[2]913
[193]914 add.filename = eap -> filename;
915 add.head = eap -> head;
916 if (WinDlgBox(HWND_DESKTOP, hwnd, AddEAProc, FM3ModHandle,
917 EAC_FRAME, &add))
918 {
919 Free_FEAList(eap -> head);
920 eap -> head = GetFileEAs(eap -> filename, FALSE, FALSE);
921 WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
922 }
[2]923 }
[193]924 break;
925 case EA_CHANGE:
926 if (!eap -> current)
927 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
928 else
929 {
[2]930
[193]931 CHAR *s;
932 USHORT control;
[2]933
[193]934 if (eap -> head && *eap -> filename)
935 {
936 switch (*(USHORT *) eap -> current -> value)
937 {
938 case EAT_EA:
939 case EAT_ASCII:
940 control = EA_ENTRY;
941 break;
942 case EAT_MVMT:
943 control = EA_MLE;
944 break;
945 case EAT_MVST:
946 control = EA_MLE;
947 break;
948 default:
949 DosBeep(250, 100);
950 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
951 control = 0;
952 }
953 if (control)
954 {
955 s = malloc(32768);
956 if (s)
957 {
958 *s = 0;
959 WinQueryDlgItemText(hwnd, control, 32767L, (PCH) s);
960 if (*s)
961 {
[2]962
[193]963 PFEA2LIST pfealist;
[2]964
[193]965 pfealist = SaveEA(eap -> filename, eap -> current, s, FALSE);
966 if (pfealist)
967 {
[2]968
[193]969 PFEA2 pfea;
[2]970
[193]971 pfea = malloc(pfealist -> cbList);
972 if (pfea)
973 {
974 memcpy(pfea, pfealist -> list,
975 pfealist -> cbList - sizeof(ULONG));
976 free(eap -> current -> pfea);
977 eap -> current -> pfea = pfea;
978 eap -> current -> name = eap -> current -> pfea -> szName;
979 eap -> current -> cbName = eap -> current -> pfea -> cbName;
980 eap -> current -> cbValue = eap -> current -> pfea -> cbValue;
981 eap -> current -> value = eap -> current -> pfea -> szName +
982 eap -> current -> pfea -> cbName + 1;
983 eap -> current -> value[eap -> current -> cbValue] = 0;
984 PostMsg(hwnd, WM_CONTROL,
985 MPFROM2SHORT(EA_LISTBOX, LN_SELECT),
986 MPVOID);
987 }
988 DosFreeMem(pfealist);
989 }
990 else
991 DosBeep(250, 100);
992 }
993 else
994 DosBeep(500, 100);
995 free(s);
996 }
997 else
998 DosBeep(100, 100);
999 }
1000 }
1001 else
1002 DosBeep(50, 100);
1003 }
1004 break;
[2]1005
[193]1006 case EA_DELETE:
1007 if (eap -> head && eap -> current)
1008 {
[2]1009
[193]1010 EAOP2 eaop;
1011 PFEA2LIST pfealist;
1012 GEA2LIST gealist;
1013 APIRET rc;
1014 SHORT sSelect;
[2]1015
[193]1016 pfealist = malloc(sizeof(FEA2LIST) + eap -> current -> cbName + 1);
1017 if (pfealist)
1018 {
1019 memset(pfealist, 0, sizeof(FEA2LIST) + eap -> current -> cbName + 1);
1020 pfealist -> cbList = sizeof(FEA2LIST) + eap -> current -> cbName + 1;
1021 pfealist -> list[0].cbName = eap -> current -> cbName;
1022 strcpy(pfealist -> list[0].szName, eap -> current -> name);
1023 pfealist -> list[0].cbValue = 0;
1024 memset(&gealist, 0, sizeof(GEA2LIST));
1025 gealist.cbList = sizeof(GEA2LIST);
1026 eaop.fpGEA2List = &gealist;
1027 eaop.fpFEA2List = pfealist;
1028 eaop.oError = 0L;
1029 rc = DosSetPathInfo(eap -> filename, FIL_QUERYEASIZE, (PVOID) & eaop,
1030 (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
1031 free(pfealist);
1032 if (!rc)
1033 {
1034 sSelect = 0;
1035 if (eap -> current == eap -> head)
1036 {
1037 eap -> head = eap -> head -> next;
1038 free(eap -> current -> pfea);
1039 free(eap -> current);
1040 eap -> current = NULL;
1041 }
1042 else
1043 {
1044 info = eap -> head;
1045 while (info)
1046 {
1047 if (info -> next == eap -> current)
1048 {
1049 sSelect++;
1050 info -> next = eap -> current -> next;
1051 free(eap -> current -> pfea);
1052 free(eap -> current);
1053 eap -> current = NULL;
1054 break;
1055 }
1056 sSelect++;
1057 info = info -> next;
1058 }
1059 }
1060 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEITEM,
1061 MPFROM2SHORT(sSelect, 0), MPVOID);
1062 WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
1063 WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
1064 WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
1065 WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
1066 WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
1067 WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
1068 MLEclearall(WinWindowFromID(hwnd, EA_MLE));
1069 WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL,
1070 MPVOID, MPVOID);
1071 if (sSelect && (SHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
1072 LM_QUERYITEMCOUNT,
1073 MPVOID, MPVOID) <=
1074 sSelect)
1075 sSelect--;
1076 WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
1077 MPFROM2SHORT(sSelect, 0),
1078 MPFROM2SHORT(TRUE, 0));
1079 }
1080 else
1081 DosBeep(50, 100);
1082 }
1083 }
1084 if (!eap -> head)
1085 WinSetDlgItemText(hwnd, EA_TEXT, GetPString(IDS_EANOEAS));
1086 break;
[2]1087
[193]1088 case IDM_HELP:
1089 if (hwndHelp)
1090 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
1091 MPFROM2SHORT(HELP_EAS, 0),
1092 MPFROMSHORT(HM_RESOURCEID));
1093 break;
[2]1094
[193]1095 case DID_OK:
1096 WinDismissDlg(hwnd, 1);
1097 break;
[2]1098
[193]1099 case DID_CANCEL:
1100 WinDismissDlg(hwnd, 0);
1101 break;
1102 }
1103 return 0;
[2]1104
[193]1105 case WM_CLOSE:
1106 break;
[2]1107
[193]1108 case WM_DESTROY:
1109 if (eap)
1110 {
1111 if (eap -> head)
1112 Free_FEAList(eap -> head);
1113 free(eap);
1114 if (hptrIcon)
1115 WinDestroyPointer(hptrIcon);
1116 hptrIcon = (HPOINTER) 0;
1117 }
1118 break;
[2]1119 }
[193]1120 return WinDefDlgProc(hwnd, msg, mp1, mp2);
[2]1121}
1122
[193]1123PVOID SaveEA(CHAR * filename, HOLDFEA * current, CHAR * newdata,
1124 BOOL silentfail)
1125{
[2]1126 /* save an ea to disk */
1127
1128 PFEA2LIST pfealist = NULL;
[193]1129 EAOP2 eaop;
1130 APIRET rc;
1131 ULONG ealen;
1132 USHORT len, *num, *plen;
1133 CHAR *p, *eaval;
[2]1134
[193]1135 if (!filename || !current)
1136 return (PVOID) pfealist;
[2]1137 len = strlen(newdata);
[193]1138 ealen = sizeof(FEA2LIST) + 24L + (ULONG) current -> cbName + 1L +
1139 (ULONG) len + 4L;
1140 switch (*(USHORT *) current -> value)
1141 {
1142 case EAT_EA:
1143 case EAT_ASCII:
1144 break;
1145 case EAT_MVST:
1146 ealen += sizeof(USHORT) * 5;
1147 p = newdata;
1148 while (*p == '\n')
1149 p++;
1150 while (*p)
1151 {
1152 if (*p == '\n' && *(p + 1))
1153 ealen += sizeof(USHORT);
1154 p++;
1155 }
1156 break;
1157 case EAT_MVMT:
1158 ealen += sizeof(USHORT) * 5;
1159 p = newdata;
1160 while (*p == '\n')
1161 p++;
1162 while (*p)
1163 {
1164 if (*p == '\n' && *(p + 1))
1165 ealen += (sizeof(USHORT) * 2);
1166 p++;
1167 }
1168 break;
1169 default:
1170 return (PVOID) pfealist;
1171 }
1172
1173 if (!DosAllocMem((PPVOID) & pfealist, ealen,
1174 OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE))
1175 {
1176 memset(pfealist, 0, ealen);
1177 pfealist -> list[0].oNextEntryOffset = 0L;
1178 pfealist -> list[0].fEA = 0; //current->fEA;
1179
1180 pfealist -> list[0].cbName = current -> cbName;
1181 memcpy(pfealist -> list[0].szName, current -> name, pfealist -> list[0].cbName + 1);
1182 eaval = pfealist -> list[0].szName + pfealist -> list[0].cbName + 1;
1183 switch (*(USHORT *) current -> value)
1184 {
[2]1185 case EAT_EA:
1186 case EAT_ASCII:
[193]1187 *(USHORT *) eaval = *(USHORT *) current -> value;
1188 eaval += sizeof(USHORT);
1189 *(USHORT *) eaval = (USHORT) len;
1190 eaval += sizeof(USHORT);
1191 memcpy(eaval, newdata, len);
1192 eaval += len;
[2]1193 break;
1194 case EAT_MVST:
[193]1195 *(USHORT *) eaval = (USHORT) EAT_MVST;
1196 eaval += sizeof(USHORT);
1197 *(USHORT *) eaval = *(USHORT *) (current -> value + sizeof(USHORT));
1198 eaval += sizeof(USHORT);
1199 num = (USHORT *) eaval;
1200 *num = 0;
1201 eaval += sizeof(USHORT);
1202 *(USHORT *) eaval = (USHORT) EAT_ASCII;
1203 eaval += sizeof(USHORT);
1204 plen = (USHORT *) eaval;
1205 *plen = 0;
1206 eaval += sizeof(USHORT);
[2]1207 p = newdata;
[193]1208 while (*p == '\n')
1209 p++;
1210 while (*p)
1211 {
1212 while (*p)
1213 {
1214 if (*p == '\n')
1215 p++;
1216 *eaval++ = *p++;
1217 (*plen)++;
1218 }
1219 if (*p || *plen)
1220 (*num)++;
1221 if (*p)
1222 {
1223 plen = (USHORT *) eaval;
1224 *plen = 0;
1225 eaval += sizeof(USHORT);
1226 }
[2]1227 }
1228 break;
[193]1229/*
1230 cbList nextoffset fea cb cbval name.......
1231 000000 3C 00 00 00 00 00 00 00 6F 0B 24 00 2E 4B 45 59 < o
1232$ .KEY
1233 .................... eat code num eat
1234 000010 50 48 52 41 53 45 53 00 DF FF 00 00 02 00 FD FF PHRASES ßÿ ýÿ
1235 len.. phrase1............................ eat
1236 000020 0C 00 4B 65 79 20 70 68 72 61 73 65 20 31 FD FF
1237 Key phrase 1ýÿ
1238 len.. phrase2......................
[2]1239 000030 0A 00 4B 65 79 20 70 68 72 61 73 65 Key phrase
[193]1240 */
1241 case EAT_MVMT:
1242 *(USHORT *) eaval = (USHORT) EAT_MVMT;
1243 eaval += sizeof(USHORT);
1244 *(USHORT *) eaval = *(USHORT *) (current -> value + sizeof(USHORT));
1245 eaval += sizeof(USHORT);
1246 num = (USHORT *) eaval;
1247 *num = 0;
1248 eaval += sizeof(USHORT);
1249 *(USHORT *) eaval = (USHORT) EAT_ASCII;
1250 eaval += sizeof(USHORT);
1251 plen = (USHORT *) eaval;
[2]1252 *plen = 0;
[193]1253 eaval += sizeof(USHORT);
1254 p = newdata;
1255 while (*p == '\n')
1256 p++;
1257 while (*p)
1258 {
1259 while (*p)
1260 {
1261 if (*p == '\n')
1262 p++;
1263 *eaval++ = *p++;
1264 (*plen)++;
1265 }
1266 if (*p || *plen)
1267 (*num)++;
1268 if (*p)
1269 {
1270 *(USHORT *) eaval = (USHORT) EAT_ASCII;
1271 eaval += sizeof(USHORT);
1272 plen = (USHORT *) eaval;
1273 *plen = 0;
[2]1274 eaval += sizeof(USHORT);
1275 }
1276 }
[193]1277 break;
1278 }
1279 pfealist -> list[0].cbValue = (ULONG) (eaval -
1280 (pfealist -> list[0].szName +
[2]1281 pfealist -> list[0].cbName + 1));
1282 eaop.fpGEA2List = (PGEA2LIST) 0;
[193]1283 eaop.fpFEA2List = pfealist;
1284 eaop.oError = 0L;
[2]1285 pfealist -> cbList = 13L + (ULONG) pfealist -> list[0].cbName +
1286 (ULONG) pfealist -> list[0].cbValue;
[193]1287
1288/*
[2]1289 {
[193]1290 FILE *fp;
1291
1292 fp = fopen("test","wb");
1293 if(fp) {
1294 fwrite(pfealist,pfealist->cbList,1,fp);
1295 fclose(fp);
1296 }
[2]1297 }
[193]1298 */
1299
1300 rc = DosSetPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & eaop,
1301 (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
[2]1302 if (rc)
1303 {
1304 DosFreeMem(pfealist);
[193]1305 pfealist = NULL;
1306 }
1307 if (rc && !silentfail)
1308 {
1309 if (rc == ERROR_ACCESS_DENIED || rc == ERROR_SHARING_VIOLATION)
1310 saymsg(MB_ENTER,
1311 HWND_DESKTOP,
1312 GetPString(IDS_OOPSTEXT),
1313 GetPString(IDS_CANTWRITEEATEXT),
[2]1314 current -> name,
[193]1315 filename);
1316 else
1317 Dos_Error(MB_ENTER,
1318 rc,
1319 HWND_DESKTOP,
1320 __FILE__,
1321 __LINE__,
1322 GetPString(IDS_ERRORWRITEEATEXT),
1323 current -> name,
[2]1324 filename,
1325 eaop.oError);
[193]1326 }
[2]1327 }
1328 return (PVOID) pfealist;
[193]1329}
1330
[2]1331HOLDFEA *GetFileEAs(CHAR * filename, BOOL ishandle, BOOL silentfail)
1332{
[193]1333 /* load eas from disk into HOLDFEA linked list */
[2]1334
[193]1335 HOLDFEA *head = NULL, *info, *last = NULL;
1336 FILESTATUS4 fsa4;
1337 HFILE handle;
[2]1338 ULONG action;
[193]1339 APIRET rc;
[2]1340
[193]1341 if (!filename)
1342 return head;
1343 if (ishandle || !DosOpen(filename, &handle, &action, 0L, 0,
1344 OPEN_ACTION_FAIL_IF_NEW |
1345 OPEN_ACTION_OPEN_IF_EXISTS,
1346 OPEN_FLAGS_NOINHERIT |
1347 OPEN_SHARE_DENYREADWRITE |
1348 OPEN_ACCESS_READWRITE, (PEAOP2) 0))
1349 {
1350 if (ishandle)
1351 handle = *(HFILE *) filename;
1352 if (!DosQueryFileInfo(handle, FIL_QUERYEASIZE, (PVOID) & fsa4,
[2]1353 (ULONG) sizeof(fsa4)) && fsa4.cbList > 4L)
[193]1354 {
1355
[2]1356 PDENA2 pdena;
1357 EAOP2 eaop;
[193]1358 PGEA2LIST pgealist;
1359 PFEA2LIST pfealist;
[2]1360 PGEA2 pgea;
1361 ULONG x = 1L, ecnt = 1L;
[193]1362
1363 pdena = malloc(65536 + 1024);
1364 if (pdena)
1365 {
1366 while (!DosEnumAttribute(ENUMEA_REFTYPE_FHANDLE, &handle, x, (PVOID) pdena,
1367 (ULONG) 65536L, &ecnt, ENUMEA_LEVEL_NO_VALUE) &&
1368 ecnt)
1369 {
1370 pgealist = malloc(64 + pdena -> cbName);
1371 if (pgealist)
1372 {
1373 pgealist -> cbList = 64 + pdena -> cbName;
1374 pgea = pgealist -> list;
1375 pgea -> oNextEntryOffset = 0L;
1376 pgea -> cbName = pdena -> cbName;
1377 memcpy(pgea -> szName, pdena -> szName, pdena -> cbName + 1);
1378 pfealist = malloc(64 + pdena -> cbName + pdena -> cbValue);
1379 if (pfealist)
1380 {
1381 memset(pfealist, 0, 64 + pdena -> cbName + pdena -> cbValue);
1382 pfealist -> cbList = 64 + pdena -> cbName + pdena -> cbValue;
1383 eaop.fpGEA2List = pgealist;
[2]1384 eaop.fpFEA2List = pfealist;
[193]1385 eaop.oError = 0L;
1386// saymsg(MB_ENTER,HWND_DESKTOP,"Debug1","\"%s\" %ld",pdena->szName,x);
1387 rc = DosQueryFileInfo(handle, FIL_QUERYEASFROMLIST, (PVOID) & eaop,
1388 (ULONG) sizeof(EAOP2));
1389 if (!rc)
1390 {
1391 info = malloc(sizeof(HOLDFEA));
1392 if (info)
1393 {
1394 info -> pfea = malloc(eaop.fpFEA2List -> cbList - sizeof(ULONG));
1395 memcpy(info -> pfea, eaop.fpFEA2List -> list,
1396 eaop.fpFEA2List -> cbList - sizeof(ULONG));
1397 info -> name = info -> pfea -> szName;
1398 info -> cbName = info -> pfea -> cbName;
1399 info -> cbValue = info -> pfea -> cbValue;
1400 info -> value = info -> pfea -> szName + info -> pfea -> cbName + 1;
1401 info -> value[info -> cbValue] = 0;
1402 info -> next = NULL;
1403 if (!head)
1404 head = info;
1405 else
1406 last -> next = info;
1407 last = info;
1408 }
1409 }
1410 else
1411 {
1412 if (!silentfail)
1413 Dos_Error(MB_ENTER,
1414 rc,
1415 HWND_DESKTOP,
1416 __FILE__,
1417 __LINE__,
1418 GetPString(IDS_ERRORREADEATEXT),
1419 pdena -> szName);
1420 }
1421 free(pfealist);
1422 }
1423 free(pgealist);
1424 }
1425 x += ecnt;
1426 }
[2]1427 free(pdena);
1428 DosPostEventSem(CompactSem);
[193]1429 }
[2]1430 }
1431 if (!ishandle)
[193]1432 DosClose(handle);
1433 }
1434 else
1435 {
1436 /* try it without opening it */
1437 if (!DosQueryPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & fsa4,
[2]1438 (ULONG) sizeof(fsa4)) && fsa4.cbList > 4L)
[193]1439 {
1440
[2]1441 PDENA2 pdena;
1442 EAOP2 eaop;
[193]1443 PGEA2LIST pgealist;
1444 PFEA2LIST pfealist;
[2]1445 PGEA2 pgea;
1446 ULONG x = 1L, ecnt = 1L;
[193]1447
1448 pdena = malloc(65536 + 1024);
1449 if (pdena)
1450 {
1451 while (!DosEnumAttribute(ENUMEA_REFTYPE_PATH, filename, x, (PVOID) pdena,
1452 (ULONG) 65536L, &ecnt, ENUMEA_LEVEL_NO_VALUE) &&
1453 ecnt)
1454 {
1455 pgealist = malloc(64 + pdena -> cbName);
1456 if (pgealist)
1457 {
1458 pgealist -> cbList = 64 + pdena -> cbName;
1459 pgea = pgealist -> list;
1460 pgea -> oNextEntryOffset = 0L;
1461 pgea -> cbName = pdena -> cbName;
1462 memcpy(pgea -> szName, pdena -> szName, pdena -> cbName + 1);
1463 pfealist = malloc(64 + pdena -> cbName + pdena -> cbValue);
1464 if (pfealist)
1465 {
1466 memset(pfealist, 0, 64 + pdena -> cbName + pdena -> cbValue);
1467 pfealist -> cbList = 64 + pdena -> cbName + pdena -> cbValue;
1468 eaop.fpGEA2List = pgealist;
[2]1469 eaop.fpFEA2List = pfealist;
[193]1470 eaop.oError = 0L;
1471// saymsg(MB_ENTER,HWND_DESKTOP,"Debug2","\"%s\" %ld",pdena->szName,x);
1472 rc = DosQueryPathInfo(filename, FIL_QUERYEASFROMLIST,
1473 (PVOID) & eaop,
1474 (ULONG) sizeof(EAOP2));
1475 if (!rc)
1476 {
1477 info = malloc(sizeof(HOLDFEA));
1478 if (info)
1479 {
1480 info -> pfea = malloc(eaop.fpFEA2List -> cbList - sizeof(ULONG));
1481 memcpy(info -> pfea, eaop.fpFEA2List -> list,
1482 eaop.fpFEA2List -> cbList - sizeof(ULONG));
1483 info -> name = info -> pfea -> szName;
1484 info -> cbName = info -> pfea -> cbName;
1485 info -> cbValue = info -> pfea -> cbValue;
1486 info -> value = info -> pfea -> szName + info -> pfea -> cbName + 1;
1487 info -> value[info -> cbValue] = 0;
1488 info -> next = NULL;
1489 if (!head)
1490 head = info;
1491 else
1492 last -> next = info;
1493 last = info;
1494 }
1495 else
1496 free(pfealist);
1497 }
1498 else
1499 {
1500 free(pfealist);
1501 if (!silentfail)
1502 {
1503 if (rc == ERROR_ACCESS_DENIED || rc == ERROR_SHARING_VIOLATION)
1504 {
1505 rc = saymsg(MB_ENTER | MB_CANCEL,
1506 HWND_DESKTOP,
1507 GetPString(IDS_OOPSTEXT),
1508 GetPString(IDS_CANTREADEATEXT),
1509 filename,
1510 pdena -> szName);
1511 if (rc == MBID_CANCEL)
1512 {
1513 free(pgealist);
1514 break;
1515 }
1516 }
1517 else
1518 Dos_Error(MB_ENTER,
1519 rc,
1520 HWND_DESKTOP,
1521 __FILE__,
1522 __LINE__,
1523 GetPString(IDS_ERRORREADEATEXT),
1524 pdena -> szName);
1525 }
1526 }
1527 }
1528 free(pgealist);
1529 }
1530 x += ecnt;
1531 }
[2]1532 free(pdena);
1533 DosPostEventSem(CompactSem);
1534 }
1535 }
1536 }
1537 return head;
[193]1538}
1539
[2]1540VOID Free_FEAList(HOLDFEA * pFEA)
1541{
1542 /* free a linked list of HOLDFEAs */
1543
[193]1544 register HOLDFEA *next;
1545
1546 while (pFEA)
1547 {
1548 /* Free linked list */
[2]1549 next = pFEA -> next;
1550 free(pFEA -> pfea);
1551 free(pFEA);
1552 pFEA = next;
1553 }
1554 DosPostEventSem(CompactSem);
1555}
Note: See TracBrowser for help on using the repository browser.