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

Last change on this file since 6688 was 6649, checked in by bird, 24 years ago

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