Changeset 6712 for trunk/src/setupapi


Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

Location:
trunk/src/setupapi
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/setupapi/devinst.c

    r6649 r6712  
    1 /* $Id: devinst.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
    21/*
    32 * SetupAPI device installer
    … …  
    1312
    1413/***********************************************************************
    15  *      DiGetClassDevs (SETUPX.304)
     14 *              DiGetClassDevs (SETUPX.304)
    1615 * Return a list of installed system devices.
    1716 * Uses HKLM\\ENUM to list devices.

  • trunk/src/setupapi/infparse.c

    r6649 r6712  
    1 /* $Id: infparse.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
    21/*
    32 * SetupX .inf file parsing functions
    … …  
    3029
    3130    if (!lphInf)
    32     return IP_ERROR;
     31        return IP_ERROR;
    3332
    3433    /* this could be improved by checking for already freed handles */
    35     if (IP_curr_handle == 0xffff)
    36     return ERR_IP_OUT_OF_HANDLES;
     34    if (IP_curr_handle == 0xffff) 
     35        return ERR_IP_OUT_OF_HANDLES;
    3736
    3837    if (hFile != HFILE_ERROR)
    3938    {
    40     InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries+1);
    41     InfList[InfNumEntries].hInf = IP_curr_handle++;
    42     InfList[InfNumEntries].hInfFile = hFile;
    43     InfList[InfNumEntries].lpInfFileName = HeapAlloc( GetProcessHeap(), 0,
     39        InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries+1);
     40        InfList[InfNumEntries].hInf = IP_curr_handle++;
     41        InfList[InfNumEntries].hInfFile = hFile;
     42        InfList[InfNumEntries].lpInfFileName = HeapAlloc( GetProcessHeap(), 0,
    4443                                                          strlen(lpInfFileName)+1);
    4544        strcpy( InfList[InfNumEntries].lpInfFileName, lpInfFileName );
    4645        *lphInf = InfList[InfNumEntries].hInf;
    47     InfNumEntries++;
    48     TRACE("ret handle %d.\n", *lphInf);
    49     return OK;
     46        InfNumEntries++;
     47        TRACE("ret handle %d.\n", *lphInf);
     48        return OK;
    5049    }
    5150    *lphInf = 0xffff;
    … …  
    5857
    5958    for (n=0; n < InfNumEntries; n++)
    60     if (InfList[n].hInf == hInf)
    61     {
    62         *ret = n;
    63         return TRUE;
    64     }
     59        if (InfList[n].hInf == hInf)
     60        {
     61            *ret = n;
     62            return TRUE;
     63        }
    6564    return FALSE;
    6665}
    67 
     66       
    6867
    6968LPCSTR IP_GetFileName(HINF16 hInf)
    … …  
    7271    if (IP_FindInf(hInf, &n))
    7372    {
    74     return InfList[n].lpInfFileName;
     73        return InfList[n].lpInfFileName;
    7574    }
    7675    return NULL;
    … …  
    8584    if (IP_FindInf(hInf, &n))
    8685    {
    87     _lclose(InfList[n].hInfFile);
    88     HeapFree(GetProcessHeap(), 0, InfList[n].lpInfFileName);
    89     for (i=n; i < InfNumEntries-1; i++)
    90         InfList[i] = InfList[i+1];
    91     InfNumEntries--;
    92     InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries);
    93     res = OK;
     86        _lclose(InfList[n].hInfFile);
     87        HeapFree(GetProcessHeap(), 0, InfList[n].lpInfFileName);
     88        for (i=n; i < InfNumEntries-1; i++)
     89            InfList[i] = InfList[i+1];
     90        InfNumEntries--;
     91        InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries);
     92        res = OK;
    9493    }
    9594    return res;
    … …  
    9796
    9897/***********************************************************************
    99  *      IpOpen16
     98 *              IpOpen16
    10099 *
    101100 */
    … …  
    107106
    108107/***********************************************************************
    109  *      IpClose16
     108 *              IpClose16
    110109 */
    111110RETERR16 WINAPI IpClose16(HINF16 hInf)
    … …  
    115114
    116115/***********************************************************************
    117  *      IpGetProfileString16
     116 *              IpGetProfileString16
    118117 */
    119 RETERR16 WINAPI IpGetProfileString16(HINF16 hInf, LPCSTR section, LPCSTR entry, LPSTR buffer, WORD buflen)
     118RETERR16 WINAPI IpGetProfileString16(HINF16 hInf, LPCSTR section, LPCSTR entry, LPSTR buffer, WORD buflen) 
    120119{
    121120    TRACE("'%s': section '%s' entry '%s'\n", IP_GetFileName(hInf), section, entry);

  • trunk/src/setupapi/setupx_main.c

    r6649 r6712  
    1 /* $Id: setupx_main.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
    21/*
    32 *      SETUPX library
    … …  
    2726 *
    2827 * 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
     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
    3433 * SU   setup (setup.c ?)
    35  * Tp   text processing (textproc.c ?)
    36  * Vcp  virtual copy module (vcp.c ?)
     34 * Tp   text processing (textproc.c ?)
     35 * Vcp  virtual copy module (vcp.c ?)
    3736 * ...
    3837 *
    … …  
    5655
    5756/***********************************************************************
    58  *      SURegOpenKey
     57 *              SURegOpenKey
    5958 */
    6059DWORD WINAPI SURegOpenKey( HKEY hkey, LPCSTR lpszSubKey, LPHKEY retkey )
    … …  
    6564
    6665/***********************************************************************
    67  *      SURegQueryValueEx
     66 *              SURegQueryValueEx
    6867 */
    6968DWORD WINAPI SURegQueryValueEx( HKEY hkey, LPSTR lpszValueName,
    … …  
    9594    while (1)
    9695    {
    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 
     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   
    127126    /* put number of entries at beginning of list */
    128127    *(DWORD *)res = count;
    … …  
    137136
    138137    for (n=0; n < count; n++)
    139     HeapFree(GetProcessHeap(), 0, *pStrings++);
     138        HeapFree(GetProcessHeap(), 0, *pStrings++);
    140139
    141140    HeapFree(GetProcessHeap(), 0, substr);
    … …  
    164163 *        Hmm, but on the other hand SETUPX_GetSubStrings() will probably
    165164 *        soon be replaced by InitSubstrData() etc. anyway.
    166  *
     165 * 
    167166 */
    168167static BOOL SETUPX_LookupRegistryString(LPSTR regstr, LPSTR buffer, DWORD buflen)
    … …  
    182181    for (n=0; n < 5; n++)
    183182    {
    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)
     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)
    194193            return FALSE;
    195194        SETUPX_IsolateSubString(&p, &q);
    … …  
    198197        strncpy(items[n], p, len);
    199198        items[n][len] = '\0';
    200     p = next;
     199        p = next;
    201200    }
    202201    TRACE("got '%s','%s','%s','%s','%s'\n",
    203             items[0], items[1], items[2], items[3], items[4]);
    204 
     202                        items[0], items[1], items[2], items[3], items[4]);
     203   
    205204    /* check root key */
    206205    if (!strcasecmp(items[0], "HKCR"))
    207     hkey = HKEY_CLASSES_ROOT;
     206        hkey = HKEY_CLASSES_ROOT;
    208207    else
    209208    if (!strcasecmp(items[0], "HKCU"))
    210     hkey = HKEY_CURRENT_USER;
     209        hkey = HKEY_CURRENT_USER;
    211210    else
    212211    if (!strcasecmp(items[0], "HKLM"))
    213     hkey = HKEY_LOCAL_MACHINE;
     212        hkey = HKEY_LOCAL_MACHINE;
    214213    else
    215214    if (!strcasecmp(items[0], "HKU"))
    216     hkey = HKEY_USERS;
     215        hkey = HKEY_USERS;
    217216    else
    218217    { /* HKR ? -> relative to key passed to GenInstallEx */
    219     FIXME("unsupported regkey '%s'\n", items[0]);
     218        FIXME("unsupported regkey '%s'\n", items[0]);
    220219        goto regfailed;
    221220    }
    … …  
    225224
    226225    if (RegQueryValueExA(hsubkey, items[2], NULL, &dwType, buffer, &buflen)
    227         != ERROR_SUCCESS)
     226                != ERROR_SUCCESS)
    228227        goto regfailed;
    229228    goto done;
    … …  
    235234        HeapFree(heap, 0, items[n]);
    236235    if (buffer)
    237     TRACE("return '%s'\n", buffer);
     236        TRACE("return '%s'\n", buffer);
    238237    return TRUE;
    239238}
    … …  
    245244
    246245    do {
    247     buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
    248     res = GetPrivateProfileStringA(NULL, NULL, NULL, buf, len, filename);
    249     len *= 2;
     246        buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
     247        res = GetPrivateProfileStringA(NULL, NULL, NULL, buf, len, filename);
     248        len *= 2;
    250249    } while ((!res) && (len < 1048576));
    251250    if (!res)
    252251    {
    253     HeapFree(GetProcessHeap(), 0, buf);
    254     return NULL;
     252        HeapFree(GetProcessHeap(), 0, buf);
     253        return NULL;
    255254    }
    256255    return buf;
    … …  
    263262
    264263    do {
    265     buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
    266     res = GetPrivateProfileSectionA(section, buf, len, filename);
    267     len *= 2;
     264        buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
     265        res = GetPrivateProfileSectionA(section, buf, len, filename);
     266        len *= 2;
    268267    } while ((!res) && (len < 1048576));
    269268    if (!res)
    270269    {
    271     HeapFree(GetProcessHeap(), 0, buf);
    272     return NULL;
     270        HeapFree(GetProcessHeap(), 0, buf);
     271        return NULL;
    273272    }
    274273    return buf;
    … …  
    277276
    278277/***********************************************************************
    279  *      InstallHinfSection
     278 *              InstallHinfSection
    280279 *
    281280 * hwnd = parent window
    … …  
    284283 * Here "DefaultInstall" is the .inf file section to be installed (optional).
    285284 * The 132 value is made of the HOW_xxx flags and sometimes 128 (-> setupx16.h).
    286  *
     285 * 
    287286 * nCmdShow = nCmdShow of CreateProcess
    288287 */
    … …  
    298297    HMODULE hMod;
    299298    MSGBOX_PROC pMessageBoxA;
    300 
     299   
    301300    TRACE("(%04x, %04x, %s, %d);\n", hwnd, hinst, lpszCmdLine, nCmdShow);
    302 
     301   
    303302    pSub = SETUPX_GetSubStrings((LPSTR)lpszCmdLine, ' ');
    304303
    305304    count = *(DWORD *)pSub;
    306305    if (count < 2) /* invalid number of arguments ? */
    307     goto end;
     306        goto end;
    308307    if (IpOpen16(*(pSub+count), &hInf) != OK)
    309308    {
    310     res = ERROR_FILE_NOT_FOUND; /* yes, correct */
    311     goto end;
     309        res = ERROR_FILE_NOT_FOUND; /* yes, correct */
     310        goto end;
    312311    }
    313312    if (GenInstall16(hInf, *(pSub+count-2), GENINSTALL_DO_ALL) != OK)
    314     goto end;
     313        goto end;
    315314    wFlags = atoi(*(pSub+count-1)) & ~128;
    316315    switch (wFlags)
    317316    {
    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 
     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   
    339338    res = OK;
    340339end:
    … …  
    343342    if (reboot)
    344343    {
    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);
     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);
    348347    }
    349348
    … …  
    360359{
    361360    { /* 0 (LDID_NULL) -- not defined */
    362     NULL,
    363     NULL
     361        NULL,
     362        NULL
    364363    },
    365364    { /* 1 (LDID_SRCPATH) = source of installation. hmm, what to do here ? */
    366     "SourcePath", /* hmm, does SETUPX have to care about updating it ?? */
    367     NULL
     365        "SourcePath", /* hmm, does SETUPX have to care about updating it ?? */
     366        NULL
    368367    },
    369368    { /* 2 (LDID_SETUPTEMP) = setup temp dir */
    370     "SetupTempDir",
    371     NULL
     369        "SetupTempDir",
     370        NULL
    372371    },
    373372    { /* 3 (LDID_UNINSTALL) = uninstall backup dir */
    374     "UninstallDir",
    375     NULL
     373        "UninstallDir",
     374        NULL
    376375    },
    377376    { /* 4 (LDID_BACKUP) = backup dir */
    378     "BackupDir",
    379     NULL
     377        "BackupDir",
     378        NULL
    380379    },
    381380    { /* 5 (LDID_SETUPSCRATCH) = setup scratch dir */
    382     "SetupScratchDir",
    383     NULL
     381        "SetupScratchDir",
     382        NULL
    384383    },
    385384    { /* 6 -- not defined */
    386     NULL,
    387     NULL
     385        NULL,
     386        NULL
    388387    },
    389388    { /* 7 -- not defined */
    390     NULL,
    391     NULL
     389        NULL,
     390        NULL
    392391    },
    393392    { /* 8 -- not defined */
    394     NULL,
    395     NULL
     393        NULL,
     394        NULL
    396395    },
    397396    { /* 9 -- not defined */
    398     NULL,
    399     NULL
     397        NULL,
     398        NULL
    400399    },
    401400    { /* 10 (LDID_WIN) = windows dir */
    402     "WinDir",
     401        "WinDir",
    403402        ""
    404403    },
    405404    { /* 11 (LDID_SYS) = system dir */
    406     "SysDir",
    407     NULL /* call GetSystemDirectory() instead */
     405        "SysDir",
     406        NULL /* call GetSystemDirectory() instead */
    408407    },
    409408    { /* 12 (LDID_IOS) = IOSubSys dir */
    410409        NULL, /* FIXME: registry string ? */
    411     "SYSTEM\\IOSUBSYS"
     410        "SYSTEM\\IOSUBSYS"
    412411    },
    413412    { /* 13 (LDID_CMD) = COMMAND dir */
    414     NULL, /* FIXME: registry string ? */
    415     "COMMAND"
     413        NULL, /* FIXME: registry string ? */
     414        "COMMAND"
    416415    },
    417416    { /* 14 (LDID_CPL) = control panel dir */
    418     NULL,
    419     ""
     417        NULL,
     418        ""
    420419    },
    421420    { /* 15 (LDID_PRINT) = windows printer dir */
    422     NULL,
    423     "SYSTEM" /* correct ?? */
     421        NULL,
     422        "SYSTEM" /* correct ?? */
    424423    },
    425424    { /* 16 (LDID_MAIL) = destination mail dir */
    426     NULL,
    427     ""
     425        NULL,
     426        ""
    428427    },
    429428    { /* 17 (LDID_INF) = INF dir */
    430     "SetupScratchDir", /* correct ? */
    431     "INF"
     429        "SetupScratchDir", /* correct ? */
     430        "INF"
    432431    },
    433432    { /* 18 (LDID_HELP) = HELP dir */
    434     NULL, /* ??? */
    435     "HELP"
     433        NULL, /* ??? */
     434        "HELP"
    436435    },
    437436    { /* 19 (LDID_WINADMIN) = Admin dir */
    438     "WinAdminDir",
    439     ""
     437        "WinAdminDir",
     438        ""
    440439    },
    441440    { /* 20 (LDID_FONTS) = Fonts dir */
    442     NULL, /* ??? */
    443     "FONTS"
     441        NULL, /* ??? */
     442        "FONTS"
    444443    },
    445444    { /* 21 (LDID_VIEWERS) = Viewers */
    446     NULL, /* ??? */
    447     "SYSTEM\\VIEWERS"
     445        NULL, /* ??? */
     446        "SYSTEM\\VIEWERS"
    448447    },
    449448    { /* 22 (LDID_VMM32) = VMM32 dir */
    450     NULL, /* ??? */
    451     "SYSTEM\\VMM32"
     449        NULL, /* ??? */
     450        "SYSTEM\\VMM32"
    452451    },
    453452    { /* 23 (LDID_COLOR) = ICM dir */
    454     "ICMPath",
    455     "SYSTEM\\COLOR"
     453        "ICMPath",
     454        "SYSTEM\\COLOR"
    456455    },
    457456    { /* 24 (LDID_APPS) = root of boot drive ? */
    458     "AppsDir",
    459     "C:\\"
     457        "AppsDir",
     458        "C:\\"
    460459    },
    461460    { /* 25 (LDID_SHARED) = shared dir */
    462     "SharedDir",
    463     ""
     461        "SharedDir",
     462        ""
    464463    },
    465464    { /* 26 (LDID_WINBOOT) = Windows boot dir */
    466     "WinBootDir",
    467     ""
     465        "WinBootDir",
     466        ""
    468467    },
    469468    { /* 27 (LDID_MACHINE) = machine specific files */
    470     "MachineDir",
    471     NULL
     469        "MachineDir",
     470        NULL
    472471    },
    473472    { /* 28 (LDID_HOST_WINBOOT) = Host Windows boot dir */
    474     "HostWinBootDir",
    475     NULL
     473        "HostWinBootDir",
     474        NULL
    476475    },
    477476    { /* 29 -- not defined */
    478     NULL,
    479     NULL
     477        NULL,
     478        NULL
    480479    },
    481480    { /* 30 (LDID_BOOT) = Root of boot drive */
    482     "BootDir",
    483     NULL
     481        "BootDir",
     482        NULL
    484483    },
    485484    { /* 31 (LDID_BOOT_HOST) = Root of boot drive host */
    486     "BootHost",
    487     NULL
     485        "BootHost",
     486        NULL
    488487    },
    489488    { /* 32 (LDID_OLD_WINBOOT) = subdir of root */
    490     "OldWinBootDir",
    491     NULL
     489        "OldWinBootDir",
     490        NULL
    492491    },
    493492    { /* 33 (LDID_OLD_WIN) = old win dir */
    494     "OldWinDir",
    495     NULL
     493        "OldWinDir",
     494        NULL
    496495    }
    497496    /* the rest (34-38) isn't too interesting, so I'll forget about it */
    498497};
    499498
    500 /*
     499/* 
    501500 * LDD  == Logical Device Descriptor
    502501 * LDID == Logical Device ID
    … …  
    528527    for (n=0; n < sizeof(LDID_Data)/sizeof(LDID_DATA); n++)
    529528    {
    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
     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
    541540        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);
     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;
    565566        }
    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     }
     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        }
    575574    }
    576575    if (hKey) RegCloseKey(hKey);
    577576}
    578 
    579 /***********************************************************************
    580  * CtlDelLdd        (SETUPX.37)
     577       
     578/***********************************************************************
     579 * CtlDelLdd            (SETUPX.37)
    581580 *
    582581 * RETURN
    … …  
    590589
    591590    if (!std_LDDs_done)
    592     SETUPX_CreateStandardLDDs();
     591        SETUPX_CreateStandardLDDs();
    593592
    594593    if (ldid < LDID_ASSIGN_START)
    595     return ERR_VCP_LDDINVALID;
     594        return ERR_VCP_LDDINVALID;
    596595
    597596    pCurr = pFirstLDD;
    … …  
    599598    while ((pCurr != NULL) && (ldid > pCurr->pldd->ldid))
    600599    {
    601     pPrev = pCurr;
    602     pCurr = pCurr->next;
     600        pPrev = pCurr;
     601        pCurr = pCurr->next;
    603602    }
    604603    if ( (pCurr == NULL) /* hit end of list */
    605604      || (ldid != pCurr->pldd->ldid) )
    606     return ERR_VCP_LDDFIND; /* correct ? */
     605        return ERR_VCP_LDDFIND; /* correct ? */
    607606
    608607    /* ok, found our victim: eliminate it */
    609608
    610609    if (pPrev)
    611     pPrev->next = pCurr->next;
     610        pPrev->next = pCurr->next;
    612611
    613612    if (pCurr == pFirstLDD)
    614     pFirstLDD = NULL;
     613        pFirstLDD = NULL;
    615614    HeapFree(GetProcessHeap(), 0, pCurr);
    616 
     615   
    617616    return OK;
    618617}
    619618
    620619/***********************************************************************
    621  *      CtlDelLdd (SETUPX.37)
     620 *              CtlDelLdd (SETUPX.37)
    622621 */
    623622RETERR16 WINAPI CtlDelLdd16(LOGDISKID16 ldid)
    … …  
    628627
    629628/***********************************************************************
    630  * CtlFindLdd       (SETUPX.35)
     629 * CtlFindLdd           (SETUPX.35)
    631630 *
    632631 * doesn't check pldd ptr validity: crash (W98SE)
    … …  
    635634 *   ERR_VCP_LDDINVALID if pldd->cbSize != structsize
    636635 *   1 in all other cases ??
    637  *
     636 * 
    638637 */
    639638RETERR16 WINAPI CtlFindLdd16(LPLOGDISKDESC pldd)
    … …  
    642641
    643642    TRACE("(%p)\n", pldd);
    644 
     643   
    645644    if (!std_LDDs_done)
    646     SETUPX_CreateStandardLDDs();
     645        SETUPX_CreateStandardLDDs();
    647646
    648647    if (pldd->cbSize != sizeof(LOGDISKDESC_S))
    … …  
    653652    while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
    654653    {
    655     pPrev = pCurr;
    656     pCurr = pCurr->next;
     654        pPrev = pCurr;
     655        pCurr = pCurr->next;
    657656    }
    658657    if ( (pCurr == NULL) /* hit end of list */
    659658      || (pldd->ldid != pCurr->pldd->ldid) )
    660     return ERR_VCP_LDDFIND; /* correct ? */
     659        return ERR_VCP_LDDFIND; /* correct ? */
    661660
    662661    memcpy(pldd, pCurr->pldd, pldd->cbSize);
    663662    /* hmm, we probably ought to strcpy() the string ptrs here */
    664 
     663   
    665664    return 1; /* what is this ?? */
    666665}
    667666
    668667/***********************************************************************
    669  * CtlSetLdd            (SETUPX.33)
     668 * CtlSetLdd                    (SETUPX.33)
    670669 *
    671670 * Set an LDD entry.
    … …  
    685684
    686685    if (!std_LDDs_done)
    687     SETUPX_CreateStandardLDDs();
     686        SETUPX_CreateStandardLDDs();
    688687
    689688    if (pldd->cbSize != sizeof(LOGDISKDESC_S))
    690     return ERR_VCP_LDDINVALID;
     689        return ERR_VCP_LDDINVALID;
    691690
    692691    heap = GetProcessHeap();
    … …  
    695694    while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
    696695    {
    697     pPrev = pCurr;
    698     pCurr = pCurr->next;
     696        pPrev = pCurr;
     697        pCurr = pCurr->next;
    699698    }
    700699    if (pCurr == NULL) /* hit end of list */
    701700    {
    702     is_new = TRUE;
     701        is_new = TRUE;
    703702        pCurr = HeapAlloc(heap, 0, sizeof(LDD_LIST));
    704703        pCurr->pldd = HeapAlloc(heap, 0, sizeof(LOGDISKDESC_S));
    … …  
    709708    {
    710709        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);
     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);
    714713    }
    715714
    … …  
    717716
    718717    if (pldd->pszPath)
    719         pCurrLDD->pszPath   = HEAP_strdupA(heap, 0, pldd->pszPath);
     718        pCurrLDD->pszPath       = HEAP_strdupA(heap, 0, pldd->pszPath);
    720719    if (pldd->pszVolLabel)
    721     pCurrLDD->pszVolLabel   = HEAP_strdupA(heap, 0, pldd->pszVolLabel);
     720        pCurrLDD->pszVolLabel   = HEAP_strdupA(heap, 0, pldd->pszVolLabel);
    722721    if (pldd->pszDiskName)
    723     pCurrLDD->pszDiskName   = HEAP_strdupA(heap, 0, pldd->pszDiskName);
     722        pCurrLDD->pszDiskName   = HEAP_strdupA(heap, 0, pldd->pszDiskName);
    724723
    725724    if (is_new) /* link into list */
    726725    {
    727726        if (pPrev)
    728     {
    729         pCurr->next = pPrev->next;
     727        {
     728            pCurr->next = pPrev->next;
    730729            pPrev->next = pCurr;
    731     }
    732     if (!pFirstLDD)
    733         pFirstLDD = pCurr;
    734     }
    735 
     730        }
     731        if (!pFirstLDD)
     732            pFirstLDD = pCurr;
     733    }
     734   
    736735    return OK;
    737736}
    … …  
    739738
    740739/***********************************************************************
    741  * CtlAddLdd        (SETUPX.36)
     740 * CtlAddLdd            (SETUPX.36)
    742741 *
    743742 * doesn't check pldd ptr validity: crash (W98SE)
    … …  
    752751
    753752/***********************************************************************
    754  * CtlGetLdd        (SETUPX.34)
     753 * CtlGetLdd            (SETUPX.34)
    755754 *
    756755 * doesn't check pldd ptr validity: crash (W98SE)
    … …  
    759758 * RETURN
    760759 *   ERR_VCP_LDDINVALID if pldd->cbSize != structsize
    761  *
     760 * 
    762761 */
    763762static RETERR16 SETUPX_GetLdd(LPLOGDISKDESC pldd)
    … …  
    766765
    767766    if (!std_LDDs_done)
    768     SETUPX_CreateStandardLDDs();
     767        SETUPX_CreateStandardLDDs();
    769768
    770769    if (pldd->cbSize != sizeof(LOGDISKDESC_S))
    … …  
    775774    while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
    776775    {
    777     pPrev = pCurr;
    778     pCurr = pCurr->next;
     776        pPrev = pCurr;
     777        pCurr = pCurr->next;
    779778    }
    780779    if (pCurr == NULL) /* hit end of list */
    781     return ERR_VCP_LDDFIND; /* correct ? */
     780        return ERR_VCP_LDDFIND; /* correct ? */
    782781
    783782    memcpy(pldd, pCurr->pldd, pldd->cbSize);
    … …  
    796795
    797796/***********************************************************************
    798  *      CtlGetLddPath       (SETUPX.38)
     797 *              CtlGetLddPath           (SETUPX.38)
    799798 *
    800799 * Gets the path of an LDD.
    … …  
    810809    if (szPath)
    811810    {
    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);
     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);
    817816        strcpy(szPath, ldd.pszPath);
    818     TRACE("ret '%s' for LDID %d\n", szPath, ldid);
     817        TRACE("ret '%s' for LDID %d\n", szPath, ldid);
    819818    }
    820819    return OK;
    … …  
    822821
    823822/***********************************************************************
    824  *      CtlSetLddPath       (SETUPX.508)
     823 *              CtlSetLddPath           (SETUPX.508)
    825824 *
    826825 * Sets the path of an LDD.
    … …  
    831830    LOGDISKDESC_S ldd;
    832831    TRACE("(%d, '%s');\n", ldid, szPath);
    833 
     832   
    834833    INIT_LDD(ldd, ldid);
    835834    ldd.pszPath = szPath;
    … …  
    848847 * -- registry lookup -->
    849848 * C:\Program Files (or C:\ if not found in registry)
    850  *
     849 * 
    851850 * FIXME:
    852851 * - maybe we ought to add a caching array for speed ? - I don't care :)
    … …  
    854853 *   LDIDs for both install and removal sections.
    855854 * - probably the whole function can be removed as installers add that on their
    856  *   own
     855 *   own 
    857856 */
    858857static BOOL SETUPX_AddCustomLDID(int ldid, INT16 hInf)
    … …  
    870869    if (!(sectionbuf = SETUPX_GetSections(filename)))
    871870    {
    872     ERR("couldn't get sections !\n");
    873     return FALSE;
     871        ERR("couldn't get sections !\n");
     872        return FALSE;
    874873    }
    875874    for (pSec=sectionbuf; *pSec; pSec += strlen(pSec)+1)
    876875    {
    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     }
     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        }
    902901next_section:
    903902    }
    … …  
    908907    if (*(DWORD *)pSub > 2)
    909908    {
    910     ERR("malformed entry '%s' ?\n", p);
    911     goto end;
     909        ERR("malformed entry '%s' ?\n", p);
     910        goto end;
    912911    }
    913912    TRACE("found section '%s'\n", *(pSub+1));
    … …  
    917916    if (!(regsectionbuf = SETUPX_GetSectionEntries(filename, *(pSub+1))))
    918917    {
    919     ERR("couldn't get registry section entries !\n");
    920     goto end;
     918        ERR("couldn't get registry section entries !\n");
     919        goto end;
    921920    }
    922921    /* sectionbuf is > 1024 bytes anyway, so use it */
    … …  
    929928end:
    930929    SETUPX_FreeSubStrings(pSub);
    931     if (sectionbuf) HeapFree(GetProcessHeap(), 0, sectionbuf);
    932     if (entrybuf)   HeapFree(GetProcessHeap(), 0, entrybuf);
    933     if (regsectionbuf)  HeapFree(GetProcessHeap(), 0, regsectionbuf);
     930    if (sectionbuf)     HeapFree(GetProcessHeap(), 0, sectionbuf);
     931    if (entrybuf)       HeapFree(GetProcessHeap(), 0, entrybuf);
     932    if (regsectionbuf)  HeapFree(GetProcessHeap(), 0, regsectionbuf);
    934933    return ret;
    935934}
    … …  
    948947    if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
    949948    {
    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);
     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);
    956955    }
    957956    else
    958     handled = TRUE;
    959 
     957        handled = TRUE;
     958   
    960959    SETUPX_GetLdd(&ldd);
    961 
     960   
    962961    if (!handled)
    963962    {
    964963        FIXME("What is LDID %d ??\n", ldid);
    965     *p = "LDID_FIXME";
     964        *p = "LDID_FIXME";
    966965    }
    967966    else
    968     *p = ldd.pszPath;
     967        *p = ldd.pszPath;
    969968
    970969    return handled;
    … …  
    972971
    973972/***********************************************************************
    974  *      GenFormStrWithoutPlaceHolders
     973 *              GenFormStrWithoutPlaceHolders
    975974 *
    976975 * ought to be pretty much implemented, I guess...
    … …  
    981980    LPSTR pDst = szDst, p, pPHBegin;
    982981    int count;
    983 
     982   
    984983    TRACE("(%p, '%s', %04x);\n", szDst, szSrc, hInf);
    985984    while (pSrc < pSrcEnd)
    986985    {
    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;
     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;
    10471046    }
    10481047    TRACE("ret '%s'\n", szDst);
    … …  
    10501049
    10511050/***********************************************************************
    1052  *      VcpOpen
     1051 *              VcpOpen
    10531052 *
    10541053 * No idea what to do here.
    … …  
    10611060
    10621061/***********************************************************************
    1063  *      VcpClose
     1062 *              VcpClose
    10641063 *
    10651064 * Is fl related to VCPDISKINFO.fl ?
    … …  
    10921091    for (n=0; n < *(DWORD *)pSub; n++)
    10931092    {
    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 
     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       
    11061105        /* 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);
     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);
    11231122        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 
     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           
    11461145    return res;
    11471146}
    11481147
    11491148/***********************************************************************
    1150  *      GenInstall
     1149 *              GenInstall
    11511150 *
    11521151 * general install function for .INF file sections
    11531152 *
    11541153 * This is not perfect - patch whenever you can !
    1155  *
     1154 * 
    11561155 * wFlags == GENINSTALL_DO_xxx
    11571156 * e.g. NetMeeting:
    … …  
    11701169    if (!pEntries)
    11711170    {
    1172     ERR("couldn't find entries for section '%s' !\n", szInstallSection);
    1173     return ERR_IP_SECT_NOT_FOUND;
     1171        ERR("couldn't find entries for section '%s' !\n", szInstallSection);
     1172        return ERR_IP_SECT_NOT_FOUND;
    11741173    }
    11751174    for (p=pEntries; *p; p +=strlen(p)+1)
    11761175    {
    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         }
     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            }
    11901189#if IMPLEMENT_THAT
    1191         else
    1192         if (!strncasecmp(p, "DelFiles", len))
    1193         {
    1194             SETUPX_DelFiles(filename, szInstallSection, pSub);
    1195         continue;
    1196         }
     1190            else
     1191            if (!strncasecmp(p, "DelFiles", len))
     1192            {
     1193                SETUPX_DelFiles(filename, szInstallSection, pSub);
     1194                continue;
     1195            }
    11971196#endif
    1198     }
    1199     if (wFlags & GENINSTALL_DO_INI)
    1200     {
     1197        }
     1198        if (wFlags & GENINSTALL_DO_INI)
     1199        {
    12011200#if IMPLEMENT_THAT
    1202         if (!strncasecmp(p, "UpdateInis", len))
    1203         {
    1204             SETUPX_UpdateInis(filename, szInstallSection, pSub);
    1205         continue;
    1206         }
     1201            if (!strncasecmp(p, "UpdateInis", len))
     1202            {
     1203                SETUPX_UpdateInis(filename, szInstallSection, pSub);
     1204                continue;
     1205            }
    12071206#endif
    1208     }
    1209     if (wFlags & GENINSTALL_DO_REG)
    1210     {
     1207        }
     1208        if (wFlags & GENINSTALL_DO_REG)
     1209        {
    12111210#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         }
     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            }
    12241223#endif
    1225     }
    1226 
    1227     SETUPX_FreeSubStrings(pSub);
     1224        }
     1225       
     1226        SETUPX_FreeSubStrings(pSub);
    12281227    }
    12291228    HeapFree(GetProcessHeap(), 0, pEntries);

  • trunk/src/setupapi/stubs.c

    r6649 r6712  
    11/* -*- tab-width: 8; c-basic-offset: 8 -*- */
    2 /* $Id: stubs.c,v 1.2 2001-09-05 13:38:24 bird Exp $ */
    32/*
    43 * SetupAPI stubs
    … …  
    1716
    1817/***********************************************************************
    19  *      SetupCloseFileQueue
     18 *              SetupCloseFileQueue
    2019 */
    2120VOID WINAPI SetupCloseFileQueue(HSPFILEQ QueueHandle)
    2221{
    23     FIXME("not implemented (setupapi.dll) \n");
    24 }
    25 
    26 /***********************************************************************
    27  *      SetupCommitFileQueueA
     22        FIXME("not implemented (setupapi.dll) \n");
     23}
     24
     25/***********************************************************************
     26 *              SetupCommitFileQueueA
    2827 */
    2928BOOL WINAPI SetupCommitFileQueueA(HWND Owner, HSPFILEQ QueueHandle,
    30                   PSP_FILE_CALLBACK_A MsgHandler,
    31                   PVOID Context)
    32 {
    33     FIXME("not implemented (setupapi.dll) \n");
    34     return FALSE;
    35 }
    36 
    37 /***********************************************************************
    38  *      SetupIterateCabinetA
     29                                  PSP_FILE_CALLBACK_A MsgHandler,
     30                                  PVOID Context)
     31{
     32        FIXME("not implemented (setupapi.dll) \n");
     33        return FALSE;
     34}
     35
     36/***********************************************************************
     37 *              SetupIterateCabinetA
    3938 */
    4039BOOL WINAPI SetupIterateCabinetA(PCSTR CabinetFile, DWORD Reserved,
    4140                                 PSP_FILE_CALLBACK_A MsgHandler, PVOID Context)
    4241{
    43     FIXME("not implemented (setupapi.dll) \n");
    44     return 0;
    45 }
    46 
    47 /***********************************************************************
    48  *      SetupIterateCabinetW
     42        FIXME("not implemented (setupapi.dll) \n");
     43        return 0;
     44}
     45
     46/***********************************************************************
     47 *              SetupIterateCabinetW
    4948 */
    5049BOOL WINAPI SetupIterateCabinetW(PWSTR CabinetFile, DWORD Reserved,
    51                                  PSP_FILE_CALLBACK_W MsgHandler, PVOID Context)
    52 {
    53     FIXME("not implemented (setupapi.dll) \n");
    54     return 0;
    55 }
    56 
    57 
    58 /***********************************************************************
    59  *      SetupGetLineTextA
     50                                 PSP_FILE_CALLBACK_W MsgHandler, PVOID Context) 
     51{
     52        FIXME("not implemented (setupapi.dll) \n");
     53        return 0;
     54}
     55
     56
     57/***********************************************************************
     58 *              SetupGetLineTextA
    6059 */
    6160BOOL WINAPI SetupGetLineTextA (PINFCONTEXT Context, HINF InfHandle,
    … …  
    6362                        DWORD ReturnBufferSize, PDWORD RequiredSize)
    6463{
    65     FIXME("not implemented (setupapi.dll) \n");
    66     return 0;
    67 }
    68 
    69 /***********************************************************************
    70  *      SetupGetStringFieldA
    71  */
    72 BOOL WINAPI SetupGetStringFieldA(PINFCONTEXT Context, DWORD FieldIndex,
     64        FIXME("not implemented (setupapi.dll) \n");
     65        return 0;
     66}
     67
     68/***********************************************************************
     69 *              SetupGetStringFieldA
     70 */
     71BOOL WINAPI SetupGetStringFieldA(PINFCONTEXT Context, DWORD FieldIndex, 
    7372                                 LPSTR ReturnBuffer, DWORD ReturnBufferSize,
    7473                                 PDWORD RequiredSize)
    7574{
    76     FIXME("not implemented (setupapi.dll) \n");
    77     return 0;
    78 }
    79 
    80 
    81 /***********************************************************************
    82  *      SetupFindNextLine
     75        FIXME("not implemented (setupapi.dll) \n");
     76        return 0;
     77}
     78
     79
     80/***********************************************************************
     81 *              SetupFindNextLine
    8382 */
    8483BOOL WINAPI SetupFindNextLine (PINFCONTEXT ContextIn, PINFCONTEXT ContextOut)
    8584{
    86     FIXME("not implemented (setupapi.dll) \n");
    87     return 0;
    88 }
    89 
    90 
    91 /***********************************************************************
    92  *      SetupInitDefaultQueueCallback
     85        FIXME("not implemented (setupapi.dll) \n");
     86        return 0;
     87}
     88
     89
     90/***********************************************************************
     91 *              SetupInitDefaultQueueCallback
    9392 */
    9493PVOID WINAPI SetupInitDefaultQueueCallback(HWND OwnerWindow)
    9594{
    96     FIXME("not implemented (setupapi.dll) \n");
    97     return 0;
    98 }
    99 
    100 /***********************************************************************
    101  *      SetupInitDefaultQueueCallbackEx
     95        FIXME("not implemented (setupapi.dll) \n");
     96        return 0;
     97}
     98
     99/***********************************************************************
     100 *              SetupInitDefaultQueueCallbackEx
    102101 */
    103102PVOID WINAPI SetupInitDefaultQueueCallbackEx(HWND OwnerWindow,
    104                          HWND AlternativeProgressWindow,
    105                          UINT ProgressMessage,
    106                          DWORD res1,
    107                          PVOID res2)
    108 {
    109     FIXME("not implemented (setupapi.dll) \n");
    110     return 0;
    111 }
    112 
    113 /***********************************************************************
    114  *      SetupCloseInfFile
     103                                             HWND AlternativeProgressWindow,
     104                                             UINT ProgressMessage,
     105                                             DWORD res1,
     106                                             PVOID res2)
     107{
     108        FIXME("not implemented (setupapi.dll) \n");
     109        return 0;
     110}
     111
     112/***********************************************************************
     113 *              SetupCloseInfFile
    115114 */
    116115VOID WINAPI SetupCloseInfFile (HINF InfHandle)
    117116{
    118     FIXME("not implemented (setupapi.dll) \n");
    119 }
    120 
    121 
    122 /***********************************************************************
    123  *      SetupDefaultQueueCallbackA
     117        FIXME("not implemented (setupapi.dll) \n");
     118}
     119
     120
     121/***********************************************************************
     122 *              SetupDefaultQueueCallbackA
    124123 */
    125124UINT WINAPI SetupDefaultQueueCallbackA (PVOID Context, UINT Notification,
    126125                                        UINT Param1, UINT Param2)
    127126{
    128     FIXME("not implemented (setupapi.dll) \n");
    129     return 0;
    130 }
    131 
    132 
    133 /***********************************************************************
    134  *      SetupFindFirstLineA
     127        FIXME("not implemented (setupapi.dll) \n");
     128        return 0;
     129}
     130
     131
     132/***********************************************************************
     133 *              SetupFindFirstLineA
    135134 */
    136135BOOL WINAPI SetupFindFirstLineA (HINF InfHandle, PCSTR Section, PCSTR Key,
    137136                                 PINFCONTEXT Context)
    138137{
    139     FIXME("not implemented (setupapi.dll) \n");
    140     return 0;
    141 }
    142 
    143 /***********************************************************************
    144  *      SetupGetLineByIndexA
     138        FIXME("not implemented (setupapi.dll) \n");
     139        return 0;
     140}
     141
     142/***********************************************************************
     143 *              SetupGetLineByIndexA
    145144 */
    146145BOOL WINAPI SetupGetLineByIndexA (HINF InfHandle, PCSTR Section, DWORD Index,
    147146                                 PINFCONTEXT Context)
    148147{
    149     FIXME("not implemented (setupapi.dll) \n");
    150     return FALSE;
    151 }
    152 
    153 
    154 /***********************************************************************
    155  *      SetupInstallFromInfSectionA
     148        FIXME("not implemented (setupapi.dll) \n");
     149        return FALSE;
     150}
     151
     152
     153/***********************************************************************
     154 *              SetupInstallFromInfSectionA
    156155 */
    157156BOOL WINAPI SetupInstallFromInfSectionA (HWND Owner, HINF InfHandle, PCSTR SectionName,
    … …  
    161160                                         PSP_DEVINFO_DATA DeviceInfoData)
    162161{
    163     FIXME("not implemented (setupapi.dll) \n");
    164     return 0;
    165 }
    166 
    167 /***********************************************************************
    168  *      SetupOpenAppendInfFileA
     162        FIXME("not implemented (setupapi.dll) \n");
     163        return 0;
     164}
     165
     166/***********************************************************************
     167 *              SetupOpenAppendInfFileA
    169168 */
    170169BOOL WINAPI SetupOpenAppendInfFileA (PCSTR FileName, HINF InfHandle,
    171                     PUINT ErrorLine)
    172 {
    173     FIXME("not implemented (setupapi.dll) \n");
    174     return FALSE;
    175 }
    176 
    177 /***********************************************************************
    178  *      SetupOpenFileQueue
     170                                    PUINT ErrorLine)
     171{
     172        FIXME("not implemented (setupapi.dll) \n");
     173        return FALSE;
     174}
     175
     176/***********************************************************************
     177 *              SetupOpenFileQueue
    179178 */
    180179HSPFILEQ WINAPI SetupOpenFileQueue (VOID)
    181180{
    182     FIXME("not implemented (setupapi.dll) \n");
    183     return (HSPFILEQ) INVALID_HANDLE_VALUE;
    184 }
    185 
    186 /***********************************************************************
    187  *      SetupOpenInfFileA
     181        FIXME("not implemented (setupapi.dll) \n");
     182        return (HSPFILEQ) INVALID_HANDLE_VALUE;
     183}
     184
     185/***********************************************************************
     186 *              SetupOpenInfFileA
    188187 */
    189188HINF WINAPI SetupOpenInfFileA (PCSTR FileName, PCSTR InfClass, DWORD InfStyle,
    190189                               PUINT ErrorLine)
    191190{
    192     FIXME("not implemented (setupapi.dll) \n");
    193     return 0;
    194 }
    195 
    196 /***********************************************************************
    197  *      SetupQueueCopyA
     191        FIXME("not implemented (setupapi.dll) \n");
     192        return 0;
     193}
     194
     195/***********************************************************************
     196 *              SetupQueueCopyA
    198197 */
    199198BOOL WINAPI SetupQueueCopyA (HSPFILEQ QueueHandle, PCSTR SourceRootPath, PCSTR SourcePath,
    200                  PCSTR SourceFileName, PCSTR SourceDescription, PCSTR SourceTagFile,
    201                  PCSTR TargetDirectory, PCSTR TargetFileName, DWORD CopyStyle)
    202 {
    203     FIXME("not implemented (setupapi.dll) \n");
    204     return FALSE;
    205 }
    206 
    207 /***********************************************************************
    208  *      SetupSetDirectoryIdA
     199                             PCSTR SourceFileName, PCSTR SourceDescription, PCSTR SourceTagFile,
     200                             PCSTR TargetDirectory, PCSTR TargetFileName, DWORD CopyStyle)
     201{
     202        FIXME("not implemented (setupapi.dll) \n");
     203        return FALSE;
     204}
     205
     206/***********************************************************************
     207 *              SetupSetDirectoryIdA
    209208 */
    210209BOOL WINAPI SetupSetDirectoryIdA (HINF InfHandle,
    211                   DWORD Id,
    212                   PCSTR Directory)
    213 {
    214     FIXME("not implemented (setupapi.dll) \n");
    215     return FALSE;
    216 }
    217 
    218 
    219 /***********************************************************************
    220  *      SetupTermDefaultQueueCallback
     210                                  DWORD Id,
     211                                  PCSTR Directory)
     212{
     213        FIXME("not implemented (setupapi.dll) \n");
     214        return FALSE;
     215}
     216
     217
     218/***********************************************************************
     219 *              SetupTermDefaultQueueCallback
    221220 */
    222221VOID WINAPI SetupTermDefaultQueueCallback (PVOID Callback)
    223222{
    224     FIXME("not implemented (setupapi.dll) \n");
    225 }
    226 
     223        FIXME("not implemented (setupapi.dll) \n");
     224}
     225
Note: See TracChangeset for help on using the changeset viewer.