source: trunk/src/setupapi/setupx_main.c@ 8001

Last change on this file since 8001 was 6712, checked in by sandervl, 24 years ago

restored old version
File size: 30.6 KB
Line 
1/*
2 * SETUPX library
3 *
4 * Copyright 1998,2000 Andreas Mohr
5 *
6 * FIXME: Rather non-functional functions for now.
7 *
8 * See:
9 * http://www.geocities.com/SiliconValley/Network/5317/drivers.html
10 * http://willemer.de/informatik/windows/inf_info.htm (German)
11 * http://www.microsoft.com/ddk/ddkdocs/win98ddk/devinst_12uw.htm
12 * DDK: setupx.h
13 * http://mmatrix.tripod.com/customsystemfolder/infsysntaxfull.html
14 * http://www.rdrop.com/~cary/html/inf_faq.html
15 * http://support.microsoft.com/support/kb/articles/q194/6/40.asp
16 *
17 * Stuff tested with:
18 * - rs405deu.exe (German Acroread 4.05 setup)
19 * - ie5setup.exe
20 * - Netmeeting
21 *
22 * FIXME:
23 * - string handling is... weird ;) (buflen etc.)
24 * - memory leaks ?
25 * - separate that mess (but probably only when it's done completely)
26 *
27 * SETUPX consists of several parts with the following acronyms/prefixes:
28 * Di device installer (devinst.c ?)
29 * Gen generic installer (geninst.c ?)
30 * Ip .INF parsing (infparse.c)
31 * LDD logical device descriptor (ldd.c ?)
32 * LDID logical device ID
33 * SU setup (setup.c ?)
34 * Tp text processing (textproc.c ?)
35 * Vcp virtual copy module (vcp.c ?)
36 * ...
37 *
38 * The SETUPX DLL is NOT thread-safe. That's why many installers urge you to
39 * "close all open applications".
40 * All in all the design of it seems to be a bit weak.
41 * Not sure whether my implementation of it is better, though ;-)
42 */
43
44#include <stdlib.h>
45#include <stdio.h>
46#include "winreg.h"
47#include "wine/winuser16.h"
48#include "setupx16.h"
49#include "setupx_private.h"
50#include "winerror.h"
51#include "heap.h"
52#include "debugtools.h"
53
54DEFAULT_DEBUG_CHANNEL(setupx);
55
56/***********************************************************************
57 * SURegOpenKey
58 */
59DWORD WINAPI SURegOpenKey( HKEY hkey, LPCSTR lpszSubKey, LPHKEY retkey )
60{
61 FIXME("(%x,%s,%p), semi-stub.\n",hkey,debugstr_a(lpszSubKey),retkey);
62 return RegOpenKeyA( hkey, lpszSubKey, retkey );
63}
64
65/***********************************************************************
66 * SURegQueryValueEx
67 */
68DWORD WINAPI SURegQueryValueEx( HKEY hkey, LPSTR lpszValueName,
69 LPDWORD lpdwReserved, LPDWORD lpdwType,
70 LPBYTE lpbData, LPDWORD lpcbData )
71{
72 FIXME("(%x,%s,%p,%p,%p,%ld), semi-stub.\n",hkey,debugstr_a(lpszValueName),
73 lpdwReserved,lpdwType,lpbData,lpcbData?*lpcbData:0);
74 return RegQueryValueExA( hkey, lpszValueName, lpdwReserved, lpdwType,
75 lpbData, lpcbData );
76}
77
78/*
79 * Returns pointer to a string list with the first entry being number
80 * of strings.
81 *
82 * Hmm. Should this be InitSubstrData(), GetFirstSubstr() and GetNextSubstr()
83 * instead?
84 */
85static LPSTR *SETUPX_GetSubStrings(LPSTR start, char delimiter)
86{
87 LPSTR p, q;
88 LPSTR *res = NULL;
89 DWORD count = 0;
90 int len;
91
92 p = start;
93
94 while (1)
95 {
96 /* find beginning of real substring */
97 while ( (*p == ' ') || (*p == '\t') || (*p == '"') ) p++;
98
99 /* find end of real substring */
100 q = p;
101 while ( (*q)
102 && (*q != ' ') && (*q != '\t') && (*q != '"')
103 && (*q != ';') && (*q != delimiter) ) q++;
104 if (q == p)
105 break;
106 len = (int)q - (int)p;
107
108 /* alloc entry for new substring in steps of 32 units and copy over */
109 if (count % 32 == 0)
110 { /* 1 for count field + current count + 32 */
111 res = HeapReAlloc(GetProcessHeap(), 0, res, (1+count+32)*sizeof(LPSTR));
112 }
113 *(res+1+count) = HeapAlloc(GetProcessHeap(), 0, len+1);
114 strncpy(*(res+1+count), p, len);
115 (*(res+1+count))[len] = '\0';
116 count++;
117
118 /* we are still within last substring (before delimiter),
119 * so get out of it */
120 while ((*q) && (*q != ';') && (*q != delimiter)) q++;
121 if ((!*q) || (*q == ';'))
122 break;
123 p = q+1;
124 }
125
126 /* put number of entries at beginning of list */
127 *(DWORD *)res = count;
128 return res;
129}
130
131static void SETUPX_FreeSubStrings(LPSTR *substr)
132{
133 DWORD count = *(DWORD *)substr;
134 LPSTR *pStrings = substr+1;
135 DWORD n;
136
137 for (n=0; n < count; n++)
138 HeapFree(GetProcessHeap(), 0, *pStrings++);
139
140 HeapFree(GetProcessHeap(), 0, substr);
141}
142
143static void SETUPX_IsolateSubString(LPSTR *begin, LPSTR *end)
144{
145 LPSTR p, q;
146
147 p = *begin;
148 q = *end;
149
150 while ((p < q) && ((*p == ' ') || (*p == '\t'))) p++;
151 while ((p < q) && (*p == '"')) p++;
152
153 while ((q-1 >= p) && ((*(q-1) == ' ') || (*(q-1) == '\t'))) q--;
154 while ((q-1 >= p) && (*(q-1) == '"')) q--;
155
156 *begin = p;
157 *end = q;
158}
159
160/*
161 * Example: HKLM,"Software\Microsoft\Windows\CurrentVersion","ProgramFilesDir",,"C:\"
162 * FIXME: use SETUPX_GetSubStrings() instead.
163 * Hmm, but on the other hand SETUPX_GetSubStrings() will probably
164 * soon be replaced by InitSubstrData() etc. anyway.
165 *
166 */
167static BOOL SETUPX_LookupRegistryString(LPSTR regstr, LPSTR buffer, DWORD buflen)
168{
169 HANDLE heap = GetProcessHeap();
170 LPSTR items[5];
171 LPSTR p, q, next;
172 int len, n;
173 HKEY hkey, hsubkey;
174 DWORD dwType;
175
176 TRACE("retrieving '%s'\n", regstr);
177
178 p = regstr;
179
180 /* isolate root key, subkey, value, flag, defval */
181 for (n=0; n < 5; n++)
182 {
183 q = strchr(p, ',');
184 if (!q)
185 {
186 if (n == 4)
187 q = p+strlen(p);
188 else
189 return FALSE;
190 }
191 next = q+1;
192 if (q < regstr)
193 return FALSE;
194 SETUPX_IsolateSubString(&p, &q);
195 len = (int)q - (int)p;
196 items[n] = HeapAlloc(heap, 0, len+1);
197 strncpy(items[n], p, len);
198 items[n][len] = '\0';
199 p = next;
200 }
201 TRACE("got '%s','%s','%s','%s','%s'\n",
202 items[0], items[1], items[2], items[3], items[4]);
203
204 /* check root key */
205 if (!strcasecmp(items[0], "HKCR"))
206 hkey = HKEY_CLASSES_ROOT;
207 else
208 if (!strcasecmp(items[0], "HKCU"))
209 hkey = HKEY_CURRENT_USER;
210 else
211 if (!strcasecmp(items[0], "HKLM"))
212 hkey = HKEY_LOCAL_MACHINE;
213 else
214 if (!strcasecmp(items[0], "HKU"))
215 hkey = HKEY_USERS;
216 else
217 { /* HKR ? -> relative to key passed to GenInstallEx */
218 FIXME("unsupported regkey '%s'\n", items[0]);
219 goto regfailed;
220 }
221
222 if (RegOpenKeyA(hkey, items[1], &hsubkey) != ERROR_SUCCESS)
223 goto regfailed;
224
225 if (RegQueryValueExA(hsubkey, items[2], NULL, &dwType, buffer, &buflen)
226 != ERROR_SUCCESS)
227 goto regfailed;
228 goto done;
229
230regfailed:
231 if (buffer) strcpy(buffer, items[4]); /* I don't care about buflen */
232done:
233 for (n=0; n < 5; n++)
234 HeapFree(heap, 0, items[n]);
235 if (buffer)
236 TRACE("return '%s'\n", buffer);
237 return TRUE;
238}
239
240static LPSTR SETUPX_GetSections(LPCSTR filename)
241{
242 LPSTR buf = NULL;
243 DWORD len = 1024, res;
244
245 do {
246 buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
247 res = GetPrivateProfileStringA(NULL, NULL, NULL, buf, len, filename);
248 len *= 2;
249 } while ((!res) && (len < 1048576));
250 if (!res)
251 {
252 HeapFree(GetProcessHeap(), 0, buf);
253 return NULL;
254 }
255 return buf;
256}
257
258static LPSTR SETUPX_GetSectionEntries(LPCSTR filename, LPCSTR section)
259{
260 LPSTR buf = NULL;
261 DWORD len = 1024, res;
262
263 do {
264 buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
265 res = GetPrivateProfileSectionA(section, buf, len, filename);
266 len *= 2;
267 } while ((!res) && (len < 1048576));
268 if (!res)
269 {
270 HeapFree(GetProcessHeap(), 0, buf);
271 return NULL;
272 }
273 return buf;
274}
275
276
277/***********************************************************************
278 * InstallHinfSection
279 *
280 * hwnd = parent window
281 * hinst = instance of SETUPX.DLL
282 * lpszCmdLine = e.g. "DefaultInstall 132 C:\MYINSTALL\MYDEV.INF"
283 * Here "DefaultInstall" is the .inf file section to be installed (optional).
284 * The 132 value is made of the HOW_xxx flags and sometimes 128 (-> setupx16.h).
285 *
286 * nCmdShow = nCmdShow of CreateProcess
287 */
288typedef INT WINAPI (*MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
289RETERR16 WINAPI InstallHinfSection16( HWND16 hwnd, HINSTANCE16 hinst, LPCSTR lpszCmdLine, INT16 nCmdShow)
290{
291 LPSTR *pSub;
292 DWORD count;
293 HINF16 hInf = 0;
294 RETERR16 res = OK;
295 WORD wFlags;
296 BOOL reboot = FALSE;
297 HMODULE hMod;
298 MSGBOX_PROC pMessageBoxA;
299
300 TRACE("(%04x, %04x, %s, %d);\n", hwnd, hinst, lpszCmdLine, nCmdShow);
301
302 pSub = SETUPX_GetSubStrings((LPSTR)lpszCmdLine, ' ');
303
304 count = *(DWORD *)pSub;
305 if (count < 2) /* invalid number of arguments ? */
306 goto end;
307 if (IpOpen16(*(pSub+count), &hInf) != OK)
308 {
309 res = ERROR_FILE_NOT_FOUND; /* yes, correct */
310 goto end;
311 }
312 if (GenInstall16(hInf, *(pSub+count-2), GENINSTALL_DO_ALL) != OK)
313 goto end;
314 wFlags = atoi(*(pSub+count-1)) & ~128;
315 switch (wFlags)
316 {
317 case HOW_ALWAYS_SILENT_REBOOT:
318 case HOW_SILENT_REBOOT:
319 reboot = TRUE;
320 break;
321 case HOW_ALWAYS_PROMPT_REBOOT:
322 case HOW_PROMPT_REBOOT:
323 if ((hMod = GetModuleHandleA("user32.dll")))
324 {
325 if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( hMod, "MessageBoxA" )))
326 {
327
328 if (pMessageBoxA(hwnd, "You must restart Wine before the new settings will take effect.\n\nDo you want to exit Wine now ?", "Systems Settings Change", MB_YESNO|MB_ICONQUESTION) == IDYES)
329 reboot = TRUE;
330 }
331 }
332 break;
333 default:
334 ERR("invalid flags %d !\n", wFlags);
335 goto end;
336 }
337
338 res = OK;
339end:
340 IpClose16(hInf);
341 SETUPX_FreeSubStrings(pSub);
342 if (reboot)
343 {
344 /* FIXME: we should have a means of terminating all wine + wineserver */
345 MESSAGE("Program or user told me to restart. Exiting Wine...\n");
346 ExitProcess(1);
347 }
348
349 return res;
350}
351
352typedef struct
353{
354 LPCSTR RegValName;
355 LPCSTR StdString; /* fallback string; sub dir of windows directory */
356} LDID_DATA;
357
358static const LDID_DATA LDID_Data[34] =
359{
360 { /* 0 (LDID_NULL) -- not defined */
361 NULL,
362 NULL
363 },
364 { /* 1 (LDID_SRCPATH) = source of installation. hmm, what to do here ? */
365 "SourcePath", /* hmm, does SETUPX have to care about updating it ?? */
366 NULL
367 },
368 { /* 2 (LDID_SETUPTEMP) = setup temp dir */
369 "SetupTempDir",
370 NULL
371 },
372 { /* 3 (LDID_UNINSTALL) = uninstall backup dir */
373 "UninstallDir",
374 NULL
375 },
376 { /* 4 (LDID_BACKUP) = backup dir */
377 "BackupDir",
378 NULL
379 },
380 { /* 5 (LDID_SETUPSCRATCH) = setup scratch dir */
381 "SetupScratchDir",
382 NULL
383 },
384 { /* 6 -- not defined */
385 NULL,
386 NULL
387 },
388 { /* 7 -- not defined */
389 NULL,
390 NULL
391 },
392 { /* 8 -- not defined */
393 NULL,
394 NULL
395 },
396 { /* 9 -- not defined */
397 NULL,
398 NULL
399 },
400 { /* 10 (LDID_WIN) = windows dir */
401 "WinDir",
402 ""
403 },
404 { /* 11 (LDID_SYS) = system dir */
405 "SysDir",
406 NULL /* call GetSystemDirectory() instead */
407 },
408 { /* 12 (LDID_IOS) = IOSubSys dir */
409 NULL, /* FIXME: registry string ? */
410 "SYSTEM\\IOSUBSYS"
411 },
412 { /* 13 (LDID_CMD) = COMMAND dir */
413 NULL, /* FIXME: registry string ? */
414 "COMMAND"
415 },
416 { /* 14 (LDID_CPL) = control panel dir */
417 NULL,
418 ""
419 },
420 { /* 15 (LDID_PRINT) = windows printer dir */
421 NULL,
422 "SYSTEM" /* correct ?? */
423 },
424 { /* 16 (LDID_MAIL) = destination mail dir */
425 NULL,
426 ""
427 },
428 { /* 17 (LDID_INF) = INF dir */
429 "SetupScratchDir", /* correct ? */
430 "INF"
431 },
432 { /* 18 (LDID_HELP) = HELP dir */
433 NULL, /* ??? */
434 "HELP"
435 },
436 { /* 19 (LDID_WINADMIN) = Admin dir */
437 "WinAdminDir",
438 ""
439 },
440 { /* 20 (LDID_FONTS) = Fonts dir */
441 NULL, /* ??? */
442 "FONTS"
443 },
444 { /* 21 (LDID_VIEWERS) = Viewers */
445 NULL, /* ??? */
446 "SYSTEM\\VIEWERS"
447 },
448 { /* 22 (LDID_VMM32) = VMM32 dir */
449 NULL, /* ??? */
450 "SYSTEM\\VMM32"
451 },
452 { /* 23 (LDID_COLOR) = ICM dir */
453 "ICMPath",
454 "SYSTEM\\COLOR"
455 },
456 { /* 24 (LDID_APPS) = root of boot drive ? */
457 "AppsDir",
458 "C:\\"
459 },
460 { /* 25 (LDID_SHARED) = shared dir */
461 "SharedDir",
462 ""
463 },
464 { /* 26 (LDID_WINBOOT) = Windows boot dir */
465 "WinBootDir",
466 ""
467 },
468 { /* 27 (LDID_MACHINE) = machine specific files */
469 "MachineDir",
470 NULL
471 },
472 { /* 28 (LDID_HOST_WINBOOT) = Host Windows boot dir */
473 "HostWinBootDir",
474 NULL
475 },
476 { /* 29 -- not defined */
477 NULL,
478 NULL
479 },
480 { /* 30 (LDID_BOOT) = Root of boot drive */
481 "BootDir",
482 NULL
483 },
484 { /* 31 (LDID_BOOT_HOST) = Root of boot drive host */
485 "BootHost",
486 NULL
487 },
488 { /* 32 (LDID_OLD_WINBOOT) = subdir of root */
489 "OldWinBootDir",
490 NULL
491 },
492 { /* 33 (LDID_OLD_WIN) = old win dir */
493 "OldWinDir",
494 NULL
495 }
496 /* the rest (34-38) isn't too interesting, so I'll forget about it */
497};
498
499/*
500 * LDD == Logical Device Descriptor
501 * LDID == Logical Device ID
502 *
503 * The whole LDD/LDID business might go into a separate file named
504 * ldd.c or logdevice.c.
505 * At the moment I don't know what the hell these functions are really doing.
506 * That's why I added reporting stubs.
507 * The only thing I do know is that I need them for the LDD/LDID infrastructure.
508 * That's why I implemented them in a way that's suitable for my purpose.
509 */
510static LDD_LIST *pFirstLDD = NULL;
511
512static BOOL std_LDDs_done = FALSE;
513
514void SETUPX_CreateStandardLDDs(void)
515{
516 HKEY hKey = 0;
517 WORD n;
518 DWORD type, len;
519 LOGDISKDESC_S ldd;
520 char buffer[MAX_PATH];
521
522 /* has to be here, otherwise loop */
523 std_LDDs_done = TRUE;
524
525 RegOpenKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup", &hKey);
526
527 for (n=0; n < sizeof(LDID_Data)/sizeof(LDID_DATA); n++)
528 {
529 buffer[0] = '\0';
530
531 len = MAX_PATH;
532 if ( (hKey) && (LDID_Data[n].RegValName)
533 && (RegQueryValueExA(hKey, LDID_Data[n].RegValName,
534 NULL, &type, buffer, &len) == ERROR_SUCCESS)
535 && (type == REG_SZ) )
536 {
537 TRACE("found value '%s' for LDID %d\n", buffer, n);
538 }
539 else
540 switch(n)
541 {
542 case LDID_SRCPATH:
543 FIXME("LDID_SRCPATH: what exactly do we have to do here ?\n");
544 strcpy(buffer, "X:\\FIXME");
545 break;
546 case LDID_SYS:
547 GetSystemDirectoryA(buffer, MAX_PATH);
548 break;
549 case LDID_APPS:
550 case LDID_MACHINE:
551 case LDID_HOST_WINBOOT:
552 case LDID_BOOT:
553 case LDID_BOOT_HOST:
554 strcpy(buffer, "C:\\");
555 break;
556 default:
557 if (LDID_Data[n].StdString)
558 {
559 DWORD len = GetWindowsDirectoryA(buffer, MAX_PATH);
560 LPSTR p;
561 p = buffer + len;
562 *p++ = '\\';
563 strcpy(p, LDID_Data[n].StdString);
564 }
565 break;
566 }
567 if (buffer[0])
568 {
569 INIT_LDD(ldd, n);
570 ldd.pszPath = buffer;
571 TRACE("LDID %d -> '%s'\n", ldd.ldid, ldd.pszPath);
572 CtlSetLdd16(&ldd);
573 }
574 }
575 if (hKey) RegCloseKey(hKey);
576}
577
578/***********************************************************************
579 * CtlDelLdd (SETUPX.37)
580 *
581 * RETURN
582 * ERR_VCP_LDDINVALID if ldid < LDID_ASSIGN_START.
583 */
584RETERR16 SETUPX_DelLdd(LOGDISKID16 ldid)
585{
586 LDD_LIST *pCurr, *pPrev = NULL;
587
588 TRACE("(%d)\n", ldid);
589
590 if (!std_LDDs_done)
591 SETUPX_CreateStandardLDDs();
592
593 if (ldid < LDID_ASSIGN_START)
594 return ERR_VCP_LDDINVALID;
595
596 pCurr = pFirstLDD;
597 /* search until we find the appropriate LDD or hit the end */
598 while ((pCurr != NULL) && (ldid > pCurr->pldd->ldid))
599 {
600 pPrev = pCurr;
601 pCurr = pCurr->next;
602 }
603 if ( (pCurr == NULL) /* hit end of list */
604 || (ldid != pCurr->pldd->ldid) )
605 return ERR_VCP_LDDFIND; /* correct ? */
606
607 /* ok, found our victim: eliminate it */
608
609 if (pPrev)
610 pPrev->next = pCurr->next;
611
612 if (pCurr == pFirstLDD)
613 pFirstLDD = NULL;
614 HeapFree(GetProcessHeap(), 0, pCurr);
615
616 return OK;
617}
618
619/***********************************************************************
620 * CtlDelLdd (SETUPX.37)
621 */
622RETERR16 WINAPI CtlDelLdd16(LOGDISKID16 ldid)
623{
624 FIXME("(%d); - please report to a.mohr@mailto.de !!!\n", ldid);
625 return SETUPX_DelLdd(ldid);
626}
627
628/***********************************************************************
629 * CtlFindLdd (SETUPX.35)
630 *
631 * doesn't check pldd ptr validity: crash (W98SE)
632 *
633 * RETURN
634 * ERR_VCP_LDDINVALID if pldd->cbSize != structsize
635 * 1 in all other cases ??
636 *
637 */
638RETERR16 WINAPI CtlFindLdd16(LPLOGDISKDESC pldd)
639{
640 LDD_LIST *pCurr, *pPrev = NULL;
641
642 TRACE("(%p)\n", pldd);
643
644 if (!std_LDDs_done)
645 SETUPX_CreateStandardLDDs();
646
647 if (pldd->cbSize != sizeof(LOGDISKDESC_S))
648 return ERR_VCP_LDDINVALID;
649
650 pCurr = pFirstLDD;
651 /* search until we find the appropriate LDD or hit the end */
652 while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
653 {
654 pPrev = pCurr;
655 pCurr = pCurr->next;
656 }
657 if ( (pCurr == NULL) /* hit end of list */
658 || (pldd->ldid != pCurr->pldd->ldid) )
659 return ERR_VCP_LDDFIND; /* correct ? */
660
661 memcpy(pldd, pCurr->pldd, pldd->cbSize);
662 /* hmm, we probably ought to strcpy() the string ptrs here */
663
664 return 1; /* what is this ?? */
665}
666
667/***********************************************************************
668 * CtlSetLdd (SETUPX.33)
669 *
670 * Set an LDD entry.
671 *
672 * RETURN
673 * ERR_VCP_LDDINVALID if pldd.cbSize != sizeof(LOGDISKDESC_S)
674 *
675 */
676RETERR16 WINAPI CtlSetLdd16(LPLOGDISKDESC pldd)
677{
678 LDD_LIST *pCurr, *pPrev = NULL;
679 LPLOGDISKDESC pCurrLDD;
680 HANDLE heap;
681 BOOL is_new = FALSE;
682
683 TRACE("(%p)\n", pldd);
684
685 if (!std_LDDs_done)
686 SETUPX_CreateStandardLDDs();
687
688 if (pldd->cbSize != sizeof(LOGDISKDESC_S))
689 return ERR_VCP_LDDINVALID;
690
691 heap = GetProcessHeap();
692 pCurr = pFirstLDD;
693 /* search until we find the appropriate LDD or hit the end */
694 while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
695 {
696 pPrev = pCurr;
697 pCurr = pCurr->next;
698 }
699 if (pCurr == NULL) /* hit end of list */
700 {
701 is_new = TRUE;
702 pCurr = HeapAlloc(heap, 0, sizeof(LDD_LIST));
703 pCurr->pldd = HeapAlloc(heap, 0, sizeof(LOGDISKDESC_S));
704 pCurr->next = NULL;
705 pCurrLDD = pCurr->pldd;
706 }
707 else
708 {
709 pCurrLDD = pCurr->pldd;
710 if (pCurrLDD->pszPath) HeapFree(heap, 0, pCurrLDD->pszPath);
711 if (pCurrLDD->pszVolLabel) HeapFree(heap, 0, pCurrLDD->pszVolLabel);
712 if (pCurrLDD->pszDiskName) HeapFree(heap, 0, pCurrLDD->pszDiskName);
713 }
714
715 memcpy(pCurrLDD, pldd, sizeof(LOGDISKDESC_S));
716
717 if (pldd->pszPath)
718 pCurrLDD->pszPath = HEAP_strdupA(heap, 0, pldd->pszPath);
719 if (pldd->pszVolLabel)
720 pCurrLDD->pszVolLabel = HEAP_strdupA(heap, 0, pldd->pszVolLabel);
721 if (pldd->pszDiskName)
722 pCurrLDD->pszDiskName = HEAP_strdupA(heap, 0, pldd->pszDiskName);
723
724 if (is_new) /* link into list */
725 {
726 if (pPrev)
727 {
728 pCurr->next = pPrev->next;
729 pPrev->next = pCurr;
730 }
731 if (!pFirstLDD)
732 pFirstLDD = pCurr;
733 }
734
735 return OK;
736}
737
738
739/***********************************************************************
740 * CtlAddLdd (SETUPX.36)
741 *
742 * doesn't check pldd ptr validity: crash (W98SE)
743 *
744 */
745static LOGDISKID16 ldid_to_add = LDID_ASSIGN_START;
746RETERR16 WINAPI CtlAddLdd16(LPLOGDISKDESC pldd)
747{
748 pldd->ldid = ldid_to_add++;
749 return CtlSetLdd16(pldd);
750}
751
752/***********************************************************************
753 * CtlGetLdd (SETUPX.34)
754 *
755 * doesn't check pldd ptr validity: crash (W98SE)
756 * What the !@#$%&*( is the difference between CtlFindLdd() and CtlGetLdd() ??
757 *
758 * RETURN
759 * ERR_VCP_LDDINVALID if pldd->cbSize != structsize
760 *
761 */
762static RETERR16 SETUPX_GetLdd(LPLOGDISKDESC pldd)
763{
764 LDD_LIST *pCurr, *pPrev = NULL;
765
766 if (!std_LDDs_done)
767 SETUPX_CreateStandardLDDs();
768
769 if (pldd->cbSize != sizeof(LOGDISKDESC_S))
770 return ERR_VCP_LDDINVALID;
771
772 pCurr = pFirstLDD;
773 /* search until we find the appropriate LDD or hit the end */
774 while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
775 {
776 pPrev = pCurr;
777 pCurr = pCurr->next;
778 }
779 if (pCurr == NULL) /* hit end of list */
780 return ERR_VCP_LDDFIND; /* correct ? */
781
782 memcpy(pldd, pCurr->pldd, pldd->cbSize);
783 /* hmm, we probably ought to strcpy() the string ptrs here */
784
785 return OK;
786}
787
788/**********************************************************************/
789
790RETERR16 WINAPI CtlGetLdd16(LPLOGDISKDESC pldd)
791{
792 FIXME("(%p); - please report to a.mohr@mailto.de !!!\n", pldd);
793 return SETUPX_GetLdd(pldd);
794}
795
796/***********************************************************************
797 * CtlGetLddPath (SETUPX.38)
798 *
799 * Gets the path of an LDD.
800 * No crash if szPath == NULL.
801 * szPath has to be at least MAX_PATH_LEN bytes long.
802 * RETURN
803 * ERR_VCP_LDDUNINIT if LDD for LDID not found.
804 */
805RETERR16 WINAPI CtlGetLddPath16(LOGDISKID16 ldid, LPSTR szPath)
806{
807 TRACE("(%d, %p);\n", ldid, szPath);
808
809 if (szPath)
810 {
811 LOGDISKDESC_S ldd;
812 INIT_LDD(ldd, ldid);
813 if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
814 return ERR_VCP_LDDUNINIT;
815 SETUPX_GetLdd(&ldd);
816 strcpy(szPath, ldd.pszPath);
817 TRACE("ret '%s' for LDID %d\n", szPath, ldid);
818 }
819 return OK;
820}
821
822/***********************************************************************
823 * CtlSetLddPath (SETUPX.508)
824 *
825 * Sets the path of an LDD.
826 * Creates LDD for LDID if not existing yet.
827 */
828RETERR16 WINAPI CtlSetLddPath16(LOGDISKID16 ldid, LPSTR szPath)
829{
830 LOGDISKDESC_S ldd;
831 TRACE("(%d, '%s');\n", ldid, szPath);
832
833 INIT_LDD(ldd, ldid);
834 ldd.pszPath = szPath;
835 return CtlSetLdd16(&ldd);
836}
837
838/*
839 * Find the value of a custom LDID in a .inf file
840 * e.g. for 49301:
841 * 49300,49301=ProgramFilesDir,5
842 * -- profile section lookup -->
843 * [ProgramFilesDir]
844 * HKLM,"Software\Microsoft\Windows\CurrentVersion","ProgramFilesDir",,"%24%"
845 * -- GenFormStrWithoutPlaceHolders16 -->
846 * HKLM,"Software\Microsoft\Windows\CurrentVersion","ProgramFilesDir",,"C:\"
847 * -- registry lookup -->
848 * C:\Program Files (or C:\ if not found in registry)
849 *
850 * FIXME:
851 * - maybe we ought to add a caching array for speed ? - I don't care :)
852 * - not sure whether the processing is correct - sometimes there are equal
853 * LDIDs for both install and removal sections.
854 * - probably the whole function can be removed as installers add that on their
855 * own
856 */
857static BOOL SETUPX_AddCustomLDID(int ldid, INT16 hInf)
858{
859 char ldidstr[6];
860 LPSTR sectionbuf = NULL, entrybuf = NULL, regsectionbuf = NULL;
861 LPCSTR filename;
862 LPSTR pSec, pEnt, pEqual, p, *pSub = NULL;
863 BOOL ret = FALSE;
864 char buffer[MAX_PATH];
865 LOGDISKDESC_S ldd;
866
867 sprintf(ldidstr, "%d", ldid);
868 filename = IP_GetFileName(hInf);
869 if (!(sectionbuf = SETUPX_GetSections(filename)))
870 {
871 ERR("couldn't get sections !\n");
872 return FALSE;
873 }
874 for (pSec=sectionbuf; *pSec; pSec += strlen(pSec)+1)
875 {
876 if (!(entrybuf = SETUPX_GetSectionEntries(filename, pSec)))
877 {
878 ERR("couldn't get section entries !\n");
879 goto end;
880 }
881 for (pEnt=entrybuf; *pEnt; pEnt += strlen(pEnt)+1)
882 {
883 if (strstr(pEnt, ldidstr))
884 {
885 pEqual = strchr(pEnt, '=');
886 if (!pEqual) /* crippled entry ?? */
887 continue;
888
889 /* make sure we found the LDID on left side of the equation */
890 if (pEnt+strlen(ldidstr) <= pEqual)
891 { /* found */
892
893 /* but we don't want entries in the strings section */
894 if (!strcasecmp(pSec, "Strings"))
895 goto next_section;
896 p = pEqual+1;
897 goto found;
898 }
899 }
900 }
901next_section:
902 }
903 goto end;
904found:
905 TRACE("found entry '%s'\n", p);
906 pSub = SETUPX_GetSubStrings(p, ',');
907 if (*(DWORD *)pSub > 2)
908 {
909 ERR("malformed entry '%s' ?\n", p);
910 goto end;
911 }
912 TRACE("found section '%s'\n", *(pSub+1));
913 /* FIXME: what are the optional flags at the end of an entry used for ?? */
914
915 /* get the location of the registry key from that section */
916 if (!(regsectionbuf = SETUPX_GetSectionEntries(filename, *(pSub+1))))
917 {
918 ERR("couldn't get registry section entries !\n");
919 goto end;
920 }
921 /* sectionbuf is > 1024 bytes anyway, so use it */
922 GenFormStrWithoutPlaceHolders16(sectionbuf, regsectionbuf, hInf);
923 ret = SETUPX_LookupRegistryString(sectionbuf, buffer, MAX_PATH);
924 TRACE("return '%s'\n", buffer);
925 INIT_LDD(ldd, ldid);
926 ldd.pszPath = buffer;
927 CtlSetLdd16(&ldd);
928end:
929 SETUPX_FreeSubStrings(pSub);
930 if (sectionbuf) HeapFree(GetProcessHeap(), 0, sectionbuf);
931 if (entrybuf) HeapFree(GetProcessHeap(), 0, entrybuf);
932 if (regsectionbuf) HeapFree(GetProcessHeap(), 0, regsectionbuf);
933 return ret;
934}
935
936/*
937 * Translate a logical disk identifier (LDID) into its string representation
938 * I'm afraid this can be totally replaced by CtlGetLddPath().
939 */
940static BOOL SETUPX_IP_TranslateLDID(int ldid, LPSTR *p, HINF16 hInf)
941{
942 BOOL handled = FALSE;
943 LOGDISKDESC_S ldd;
944
945 ldd.cbSize = sizeof(LOGDISKDESC_S);
946 ldd.ldid = ldid;
947 if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
948 {
949 /* hmm, it seems the installers already do the work for us
950 * (by calling CtlSetLddPath) that SETUPX_AddCustomLDID
951 * is supposed to do. Grmbl ;-)
952 * Well, I'll leave it here anyway, but print error... */
953 ERR("hmm, LDID %d not registered yet !?\n", ldid);
954 handled = SETUPX_AddCustomLDID(ldid, hInf);
955 }
956 else
957 handled = TRUE;
958
959 SETUPX_GetLdd(&ldd);
960
961 if (!handled)
962 {
963 FIXME("What is LDID %d ??\n", ldid);
964 *p = "LDID_FIXME";
965 }
966 else
967 *p = ldd.pszPath;
968
969 return handled;
970}
971
972/***********************************************************************
973 * GenFormStrWithoutPlaceHolders
974 *
975 * ought to be pretty much implemented, I guess...
976 */
977void WINAPI GenFormStrWithoutPlaceHolders16( LPSTR szDst, LPCSTR szSrc, HINF16 hInf)
978{
979 LPCSTR pSrc = szSrc, pSrcEnd = szSrc + strlen(szSrc);
980 LPSTR pDst = szDst, p, pPHBegin;
981 int count;
982
983 TRACE("(%p, '%s', %04x);\n", szDst, szSrc, hInf);
984 while (pSrc < pSrcEnd)
985 {
986 p = strchr(pSrc, '%');
987 if (p)
988 {
989 count = (int)p - (int)pSrc;
990 strncpy(pDst, pSrc, count);
991 pSrc += count;
992 pDst += count;
993 pPHBegin = p+1;
994 p = strchr(pPHBegin, '%');
995 if (p)
996 {
997 char placeholder[80]; /* that really ought to be enough ;) */
998 int ldid;
999 BOOL done = TRUE;
1000 count = (int)p - (int)pPHBegin;
1001 strncpy(placeholder, pPHBegin, count);
1002 placeholder[count] = '\0';
1003 ldid = atoi(placeholder);
1004 if (ldid)
1005 {
1006 LPSTR p;
1007 done = SETUPX_IP_TranslateLDID(ldid, &p, hInf);
1008 strcpy(pDst, p);
1009 if (done)
1010 pDst += strlen(pDst);
1011 }
1012 else
1013 { /* hmm, string placeholder. Need to look up
1014 in the [strings] section of the hInf */
1015 DWORD ret;
1016 char buf[256]; /* long enough ? */
1017
1018 ret = GetPrivateProfileStringA("strings", placeholder, "",
1019 buf, 256, IP_GetFileName(hInf));
1020 if (ret)
1021 {
1022 strcpy(pDst, buf);
1023 pDst += strlen(buf);
1024 }
1025 else
1026 {
1027 ERR("placeholder string '%s' not found !\n", placeholder);
1028 done = FALSE;
1029 }
1030 }
1031 if (!done)
1032 { /* copy raw placeholder string over */
1033 count = (int)p - (int)pPHBegin + 2;
1034 strncpy(pDst, pPHBegin-1, count);
1035 pDst += count;
1036
1037 }
1038 pSrc = p+1;
1039 continue;
1040 }
1041 }
1042
1043 /* copy the remaining source string over */
1044 strncpy(pDst, pSrc, (int)pSrcEnd - (int)pSrc + 1);
1045 break;
1046 }
1047 TRACE("ret '%s'\n", szDst);
1048}
1049
1050/***********************************************************************
1051 * VcpOpen
1052 *
1053 * No idea what to do here.
1054 */
1055RETERR16 WINAPI VcpOpen16(VIFPROC vifproc, LPARAM lparamMsgRef)
1056{
1057 FIXME("(%p, %08lx), stub.\n", vifproc, lparamMsgRef);
1058 return OK;
1059}
1060
1061/***********************************************************************
1062 * VcpClose
1063 *
1064 * Is fl related to VCPDISKINFO.fl ?
1065 */
1066RETERR16 WINAPI VcpClose16(WORD fl, LPCSTR lpszBackupDest)
1067{
1068 FIXME("(%04x, '%s'), stub.\n", fl, lpszBackupDest);
1069 return OK;
1070}
1071
1072/*
1073 * Copy all items in a CopyFiles entry over to the destination
1074 *
1075 * - VNLP_xxx is what is given as flags for a .INF CopyFiles section
1076 */
1077static BOOL SETUPX_CopyFiles(LPSTR *pSub, HINF16 hInf)
1078{
1079 BOOL res = FALSE;
1080 unsigned int n;
1081 LPCSTR filename = IP_GetFileName(hInf);
1082 LPSTR pCopyEntry;
1083 char pDestStr[MAX_PATH];
1084 LPSTR pSrcDir, pDstDir;
1085 LPSTR pFileEntries, p;
1086 WORD ldid;
1087 LOGDISKDESC_S ldd;
1088 LPSTR *pSubFile;
1089 LPSTR pSrcFile, pDstFile;
1090
1091 for (n=0; n < *(DWORD *)pSub; n++)
1092 {
1093 pCopyEntry = *(pSub+1+n);
1094 if (*pCopyEntry == '@')
1095 {
1096 ERR("single file not handled yet !\n");
1097 continue;
1098 }
1099
1100 /* get source directory for that entry */
1101 INIT_LDD(ldd, LDID_SRCPATH);
1102 SETUPX_GetLdd(&ldd);
1103 pSrcDir = ldd.pszPath;
1104
1105 /* get destination directory for that entry */
1106 if (!(GetPrivateProfileStringA("DestinationDirs", pCopyEntry, "",
1107 pDestStr, sizeof(pDestStr), filename)))
1108 continue;
1109
1110 /* translate destination dir if given as LDID */
1111 ldid = atoi(pDestStr);
1112 if (ldid)
1113 {
1114 if (!(SETUPX_IP_TranslateLDID(ldid, &pDstDir, hInf)))
1115 continue;
1116 }
1117 else
1118 pDstDir = pDestStr;
1119
1120 /* now that we have the destination dir, iterate over files to copy */
1121 pFileEntries = SETUPX_GetSectionEntries(filename, pCopyEntry);
1122 for (p=pFileEntries; *p; p +=strlen(p)+1)
1123 {
1124 pSubFile = SETUPX_GetSubStrings(p, ',');
1125 pSrcFile = *(pSubFile+1);
1126 pDstFile = (*(DWORD *)pSubFile > 1) ? *(pSubFile+2) : pSrcFile;
1127 TRACE("copying file '%s\\%s' to '%s\\%s'\n", pSrcDir, pSrcFile, pDstDir, pDstFile);
1128 if (*(DWORD *)pSubFile > 2)
1129 {
1130 WORD flag;
1131 if ((flag = atoi(*(pSubFile+3)))) /* ah, flag */
1132 {
1133 if (flag & 0x2c)
1134 FIXME("VNLP_xxx flag %d not handled yet.\n", flag);
1135 }
1136 else
1137 FIXME("temp file name '%s' given. Need to register in wininit.ini !\n", *(pSubFile+3)); /* strong guess that this is VcpQueueCopy() */
1138 }
1139 SETUPX_FreeSubStrings(pSubFile);
1140 /* we don't copy ANYTHING yet ! (I'm too lazy and want to verify
1141 * this first before destroying whole partitions ;-) */
1142 }
1143 }
1144
1145 return res;
1146}
1147
1148/***********************************************************************
1149 * GenInstall
1150 *
1151 * general install function for .INF file sections
1152 *
1153 * This is not perfect - patch whenever you can !
1154 *
1155 * wFlags == GENINSTALL_DO_xxx
1156 * e.g. NetMeeting:
1157 * first call GENINSTALL_DO_REGSRCPATH | GENINSTALL_DO_FILES,
1158 * second call GENINSTALL_DO_LOGCONFIG | CFGAUTO | INI2REG | REG | INI
1159 */
1160RETERR16 WINAPI GenInstall16(HINF16 hInfFile, LPCSTR szInstallSection, WORD wFlags)
1161{
1162 LPCSTR filename = IP_GetFileName(hInfFile);
1163 LPSTR pEntries, p, pEnd;
1164 DWORD len;
1165 LPSTR *pSub;
1166
1167 FIXME("(%04x, '%s', %04x), semi-stub. Please implement additional operations here !\n", hInfFile, szInstallSection, wFlags);
1168 pEntries = SETUPX_GetSectionEntries(filename, szInstallSection);
1169 if (!pEntries)
1170 {
1171 ERR("couldn't find entries for section '%s' !\n", szInstallSection);
1172 return ERR_IP_SECT_NOT_FOUND;
1173 }
1174 for (p=pEntries; *p; p +=strlen(p)+1)
1175 {
1176 pEnd = strchr(p, '=');
1177 if (!pEnd) continue;
1178 pSub = SETUPX_GetSubStrings(pEnd+1, ','); /* split entries after the '=' */
1179 SETUPX_IsolateSubString(&p, &pEnd);
1180 len = (int)pEnd - (int)p;
1181
1182 if (wFlags & GENINSTALL_DO_FILES)
1183 {
1184 if (!strncasecmp(p, "CopyFiles", len))
1185 {
1186 SETUPX_CopyFiles(pSub, hInfFile);
1187 continue;
1188 }
1189#if IMPLEMENT_THAT
1190 else
1191 if (!strncasecmp(p, "DelFiles", len))
1192 {
1193 SETUPX_DelFiles(filename, szInstallSection, pSub);
1194 continue;
1195 }
1196#endif
1197 }
1198 if (wFlags & GENINSTALL_DO_INI)
1199 {
1200#if IMPLEMENT_THAT
1201 if (!strncasecmp(p, "UpdateInis", len))
1202 {
1203 SETUPX_UpdateInis(filename, szInstallSection, pSub);
1204 continue;
1205 }
1206#endif
1207 }
1208 if (wFlags & GENINSTALL_DO_REG)
1209 {
1210#if IMPLEMENT_THAT
1211 /* probably use SUReg*() functions here */
1212 if (!strncasecmp(p, "AddReg", len))
1213 {
1214 SETUPX_AddReg(filename, szInstallSection, pSub);
1215 continue;
1216 }
1217 else
1218 if (!strncasecmp(p, "DelReg", len))
1219 {
1220 SETUPX_DelReg(filename, szInstallSection, pSub);
1221 continue;
1222 }
1223#endif
1224 }
1225
1226 SETUPX_FreeSubStrings(pSub);
1227 }
1228 HeapFree(GetProcessHeap(), 0, pEntries);
1229 return OK;
1230}
Note: See TracBrowser for help on using the repository browser.