dlls/setupapi/query.c

   1 /*
   2  * setupapi query functions
   3  *
   4  * Copyright 2006 James Hawkins
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "setupapi.h"
  29 #include "advpub.h"
  30 #include "winnls.h"
  31 #include "wine/debug.h"
  32 #include "setupapi_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  35
  36 #ifdef __i386__
  37 static const WCHAR source_disks_names_platform[] =
  38     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','x','8','6',0};
  39 static const WCHAR source_disks_files_platform[] =
  40     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s','.','x','8','6',0};
  41 #elif defined(__x86_64__)
  42 static const WCHAR source_disks_names_platform[] =
  43     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','a','m','d','6','4',0};
  44 static const WCHAR source_disks_files_platform[] =
  45     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s','.','a','m','d','6','4',0};
  46 #elif defined(__arm__)
  47 static const WCHAR source_disks_names_platform[] =
  48     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','a','r','m',0};
  49 static const WCHAR source_disks_files_platform[] =
  50     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s','.','a','r','m',0};
  51 #elif defined(__aarch64__)
  52 static const WCHAR source_disks_names_platform[] =
  53     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s','.','a','r','m','6','4',0};
  54 static const WCHAR source_disks_files_platform[] =
  55     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s','.','a','r','m','6','4',0};
  56 #else  /* FIXME: other platforms */
  57 static const WCHAR source_disks_names_platform[] =
  58     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s',0};
  59 static const WCHAR source_disks_files_platform[] =
  60     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s',0};
  61 #endif
  62 static const WCHAR source_disks_names[] =
  63     {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s',0};
  64 static const WCHAR source_disks_files[] =
  65     {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s',0};
  66
  67 /* fills the PSP_INF_INFORMATION struct fill_info is TRUE
  68  * always returns the required size of the information
  69  */
  70 static BOOL fill_inf_info(HINF inf, PSP_INF_INFORMATION buffer, DWORD size, DWORD *required)
  71 {
  72     LPCWSTR filename = PARSER_get_inf_filename(inf);
  73     DWORD total_size = FIELD_OFFSET(SP_INF_INFORMATION, VersionData)
  74                         + (lstrlenW(filename) + 1) * sizeof(WCHAR);
  75
  76     if (required) *required = total_size;
  77
  78     /* FIXME: we need to parse the INF file to find the correct version info */
  79     if (buffer)
  80     {
  81         if (size < total_size)
  82         {
  83             SetLastError(ERROR_INSUFFICIENT_BUFFER);
  84             return FALSE;
  85         }
  86         buffer->InfStyle = INF_STYLE_WIN4;
  87         buffer->InfCount = 1;
  88         /* put the filename in buffer->VersionData */
  89         lstrcpyW((LPWSTR)&buffer->VersionData[0], filename);
  90     }
  91     return TRUE;
  92 }
  93
  94 static HINF search_for_inf(LPCVOID InfSpec, DWORD SearchControl)
  95 {
  96     HINF hInf = INVALID_HANDLE_VALUE;
  97     WCHAR inf_path[MAX_PATH];
  98
  99     static const WCHAR infW[] = {'\\','i','n','f','\\',0};
 100     static const WCHAR system32W[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
 101
 102     if (SearchControl == INFINFO_REVERSE_DEFAULT_SEARCH)
 103     {
 104         GetWindowsDirectoryW(inf_path, MAX_PATH);
 105         lstrcatW(inf_path, system32W);
 106         lstrcatW(inf_path, InfSpec);
 107
 108         hInf = SetupOpenInfFileW(inf_path, NULL,
 109                                  INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
 110         if (hInf != INVALID_HANDLE_VALUE)
 111             return hInf;
 112
 113         GetWindowsDirectoryW(inf_path, MAX_PATH);
 114         lstrcpyW(inf_path, infW);
 115         lstrcatW(inf_path, InfSpec);
 116
 117         return SetupOpenInfFileW(inf_path, NULL,
 118                                  INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
 119     }
 120
 121     return INVALID_HANDLE_VALUE;
 122 }
 123
 124 /***********************************************************************
 125  *      SetupGetInfInformationA    (SETUPAPI.@)
 126  *
 127  */
 128 BOOL WINAPI SetupGetInfInformationA(LPCVOID InfSpec, DWORD SearchControl,
 129                                     PSP_INF_INFORMATION ReturnBuffer,
 130                                     DWORD ReturnBufferSize, PDWORD RequiredSize)
 131 {
 132     LPWSTR inf = (LPWSTR)InfSpec;
 133     DWORD len;
 134     BOOL ret;
 135
 136     if (InfSpec && SearchControl >= INFINFO_INF_NAME_IS_ABSOLUTE)
 137     {
 138         len = MultiByteToWideChar(CP_ACP, 0, InfSpec, -1, NULL, 0);
 139         inf = malloc(len * sizeof(WCHAR));
 140         if (!inf)
 141         {
 142             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 143             return FALSE;
 144         }
 145         MultiByteToWideChar(CP_ACP, 0, InfSpec, -1, inf, len);
 146     }
 147
 148     ret = SetupGetInfInformationW(inf, SearchControl, ReturnBuffer,
 149                                   ReturnBufferSize, RequiredSize);
 150
 151     if (SearchControl >= INFINFO_INF_NAME_IS_ABSOLUTE)
 152         free(inf);
 153
 154     return ret;
 155 }
 156
 157 /***********************************************************************
 158  *      SetupGetInfInformationW    (SETUPAPI.@)
 159  *
 160  * BUGS
 161  *   Only handles the case when InfSpec is an INF handle.
 162  */
 163 BOOL WINAPI SetupGetInfInformationW(LPCVOID InfSpec, DWORD SearchControl,
 164                                      PSP_INF_INFORMATION ReturnBuffer,
 165                                      DWORD ReturnBufferSize, PDWORD RequiredSize)
 166 {
 167     HINF inf;
 168     BOOL ret;
 169     DWORD infSize;
 170
 171     TRACE("(%p, %ld, %p, %ld, %p)\n", InfSpec, SearchControl, ReturnBuffer,
 172            ReturnBufferSize, RequiredSize);
 173
 174     if (!InfSpec)
 175     {
 176         if (SearchControl == INFINFO_INF_SPEC_IS_HINF)
 177             SetLastError(ERROR_INVALID_HANDLE);
 178         else
 179             SetLastError(ERROR_INVALID_PARAMETER);
 180
 181         return FALSE;
 182     }
 183
 184     switch (SearchControl)
 185     {
 186         case INFINFO_INF_SPEC_IS_HINF:
 187             inf = (HINF)InfSpec;
 188             break;
 189         case INFINFO_INF_NAME_IS_ABSOLUTE:
 190         case INFINFO_DEFAULT_SEARCH:
 191             inf = SetupOpenInfFileW(InfSpec, NULL,
 192                                     INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
 193             break;
 194         case INFINFO_REVERSE_DEFAULT_SEARCH:
 195             inf = search_for_inf(InfSpec, SearchControl);
 196             break;
 197         case INFINFO_INF_PATH_LIST_SEARCH:
 198             FIXME("Unhandled search control: %ld\n", SearchControl);
 199
 200             if (RequiredSize)
 201                 *RequiredSize = 0;
 202
 203             return FALSE;
 204         default:
 205             SetLastError(ERROR_INVALID_PARAMETER);
 206             return FALSE;
 207     }
 208
 209     if (inf == INVALID_HANDLE_VALUE)
 210     {
 211         SetLastError(ERROR_FILE_NOT_FOUND);
 212         return FALSE;
 213     }
 214
 215     ret = fill_inf_info(inf, ReturnBuffer, ReturnBufferSize, &infSize);
 216     if (!ReturnBuffer && (ReturnBufferSize >= infSize))
 217     {
 218         SetLastError(ERROR_INVALID_PARAMETER);
 219         ret = FALSE;
 220     }
 221     if (RequiredSize) *RequiredSize = infSize;
 222
 223     if (SearchControl >= INFINFO_INF_NAME_IS_ABSOLUTE)
 224         SetupCloseInfFile(inf);
 225
 226     return ret;
 227 }
 228
 229 /***********************************************************************
 230  *      SetupQueryInfFileInformationA    (SETUPAPI.@)
 231  */
 232 BOOL WINAPI SetupQueryInfFileInformationA(PSP_INF_INFORMATION InfInformation,
 233                                           UINT InfIndex, PSTR ReturnBuffer,
 234                                           DWORD ReturnBufferSize, PDWORD RequiredSize)
 235 {
 236     LPWSTR filenameW;
 237     DWORD size;
 238     BOOL ret;
 239
 240     ret = SetupQueryInfFileInformationW(InfInformation, InfIndex, NULL, 0, &size);
 241     if (!ret)
 242         return FALSE;
 243
 244     filenameW = malloc(size * sizeof(WCHAR));
 245
 246     ret = SetupQueryInfFileInformationW(InfInformation, InfIndex,
 247                                         filenameW, size, &size);
 248     if (!ret)
 249     {
 250         free(filenameW);
 251         return FALSE;
 252     }
 253
 254     if (RequiredSize)
 255         *RequiredSize = size;
 256
 257     if (!ReturnBuffer)
 258     {
 259         free(filenameW);
 260         if (ReturnBufferSize)
 261         {
 262             SetLastError(ERROR_INVALID_PARAMETER);
 263             return FALSE;
 264         }
 265
 266         return TRUE;
 267     }
 268
 269     if (size > ReturnBufferSize)
 270     {
 271         free(filenameW);
 272         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 273         return FALSE;
 274     }
 275
 276     WideCharToMultiByte(CP_ACP, 0, filenameW, -1, ReturnBuffer, size, NULL, NULL);
 277     free(filenameW);
 278
 279     return ret;
 280 }
 281
 282 /***********************************************************************
 283  *      SetupQueryInfFileInformationW    (SETUPAPI.@)
 284  */
 285 BOOL WINAPI SetupQueryInfFileInformationW(PSP_INF_INFORMATION InfInformation,
 286                                           UINT InfIndex, PWSTR ReturnBuffer,
 287                                           DWORD ReturnBufferSize, PDWORD RequiredSize)
 288 {
 289     DWORD len;
 290     LPWSTR ptr;
 291
 292     TRACE("(%p, %u, %p, %ld, %p) Stub!\n", InfInformation, InfIndex,
 293           ReturnBuffer, ReturnBufferSize, RequiredSize);
 294
 295     if (!InfInformation)
 296     {
 297         SetLastError(ERROR_INVALID_PARAMETER);
 298         return FALSE;
 299     }
 300
 301     if (InfIndex != 0)
 302         FIXME("Appended INF files are not handled\n");
 303
 304     ptr = (LPWSTR)InfInformation->VersionData;
 305     len = lstrlenW(ptr);
 306
 307     if (RequiredSize)
 308         *RequiredSize = len + 1;
 309
 310     if (!ReturnBuffer)
 311         return TRUE;
 312
 313     if (ReturnBufferSize < len)
 314     {
 315         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 316         return FALSE;
 317     }
 318
 319     lstrcpyW(ReturnBuffer, ptr);
 320     return TRUE;
 321 }
 322
 323 /***********************************************************************
 324  *            SetupGetSourceFileLocationA   (SETUPAPI.@)
 325  */
 326
 327 BOOL WINAPI SetupGetSourceFileLocationA( HINF hinf, PINFCONTEXT context, PCSTR filename,
 328                                          PUINT source_id, PSTR buffer, DWORD buffer_size,
 329                                          PDWORD required_size )
 330 {
 331     BOOL ret = FALSE;
 332     WCHAR *filenameW = NULL, *bufferW = NULL;
 333     DWORD required;
 334     INT size;
 335
 336     TRACE("%p, %p, %s, %p, %p, 0x%08lx, %p\n", hinf, context, debugstr_a(filename), source_id,
 337           buffer, buffer_size, required_size);
 338
 339     if (filename && *filename && !(filenameW = strdupAtoW( filename )))
 340         return FALSE;
 341
 342     if (!SetupGetSourceFileLocationW( hinf, context, filenameW, source_id, NULL, 0, &required ))
 343         goto done;
 344
 345     if (!(bufferW = malloc( required * sizeof(WCHAR) )))
 346         goto done;
 347
 348     if (!SetupGetSourceFileLocationW( hinf, context, filenameW, source_id, bufferW, required, NULL ))
 349         goto done;
 350
 351     size = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
 352     if (required_size) *required_size = size;
 353
 354     if (buffer)
 355     {
 356         if (buffer_size >= size)
 357             WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, buffer_size, NULL, NULL );
 358         else
 359         {
 360             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 361             goto done;
 362         }
 363     }
 364     ret = TRUE;
 365
 366  done:
 367     free( filenameW );
 368     free( bufferW );
 369     return ret;
 370 }
 371
 372 /***********************************************************************
 373  *            SetupGetSourceFileLocationW   (SETUPAPI.@)
 374  */
 375
 376 BOOL WINAPI SetupGetSourceFileLocationW( HINF hinf, PINFCONTEXT context, PCWSTR filename,
 377                                          PUINT source_id, PWSTR buffer, DWORD buffer_size,
 378                                          PDWORD required_size )
 379 {
 380     INFCONTEXT ctx;
 381     int id;
 382
 383     TRACE("%p, %p, %s, %p, %p, 0x%08lx, %p\n", hinf, context, debugstr_w(filename), source_id,
 384           buffer, buffer_size, required_size);
 385
 386     if (context)
 387     {
 388         WCHAR *ctx_filename;
 389         DWORD filename_size;
 390
 391         if (!SetupGetStringFieldW( context, 1, NULL, 0, &filename_size ))
 392             return FALSE;
 393         if (!(ctx_filename = malloc( filename_size * sizeof(WCHAR) )))
 394             return FALSE;
 395         SetupGetStringFieldW( context, 1, ctx_filename, filename_size, NULL );
 396
 397         if (!SetupFindFirstLineW( hinf, source_disks_files_platform, ctx_filename, &ctx ) &&
 398             !SetupFindFirstLineW( hinf, source_disks_files, ctx_filename, &ctx ))
 399         {
 400             free( ctx_filename );
 401             return FALSE;
 402         }
 403
 404         free( ctx_filename );
 405     }
 406     else
 407     {
 408         if (!SetupFindFirstLineW( hinf, source_disks_files_platform, filename, &ctx ) &&
 409             !SetupFindFirstLineW( hinf, source_disks_files, filename, &ctx ))
 410         {
 411             return FALSE;
 412         }
 413     }
 414
 415     if (!SetupGetIntField( &ctx, 1, &id ))
 416         return FALSE;
 417     *source_id = id;
 418
 419     if (SetupGetStringFieldW( &ctx, 2, buffer, buffer_size, required_size ))
 420         return TRUE;
 421
 422     if (required_size) *required_size = 1;
 423     if (buffer)
 424     {
 425         if (buffer_size >= 1) buffer[0] = 0;
 426         else
 427         {
 428             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 429             return FALSE;
 430         }
 431     }
 432     return TRUE;
 433 }
 434
 435 /***********************************************************************
 436  *            SetupGetSourceInfoA  (SETUPAPI.@)
 437  */
 438
 439 BOOL WINAPI SetupGetSourceInfoA( HINF hinf, UINT source_id, UINT info,
 440                                  PSTR buffer, DWORD buffer_size, LPDWORD required_size )
 441 {
 442     BOOL ret = FALSE;
 443     WCHAR *bufferW = NULL;
 444     DWORD required;
 445     INT size;
 446
 447     TRACE("%p, %d, %d, %p, %ld, %p\n", hinf, source_id, info, buffer, buffer_size,
 448           required_size);
 449
 450     if (!SetupGetSourceInfoW( hinf, source_id, info, NULL, 0, &required ))
 451         return FALSE;
 452
 453     if (!(bufferW = malloc( required * sizeof(WCHAR) )))
 454         return FALSE;
 455
 456     if (!SetupGetSourceInfoW( hinf, source_id, info, bufferW, required, NULL ))
 457         goto done;
 458
 459     size = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
 460     if (required_size) *required_size = size;
 461
 462     if (buffer)
 463     {
 464         if (buffer_size >= size)
 465             WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, buffer_size, NULL, NULL );
 466         else
 467         {
 468             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 469             goto done;
 470         }
 471     }
 472     ret = TRUE;
 473
 474  done:
 475     free( bufferW );
 476     return ret;
 477 }
 478
 479 /***********************************************************************
 480  *            SetupGetSourceInfoW  (SETUPAPI.@)
 481  */
 482
 483 BOOL WINAPI SetupGetSourceInfoW( HINF hinf, UINT source_id, UINT info,
 484                                  PWSTR buffer, DWORD buffer_size, LPDWORD required_size )
 485 {
 486     INFCONTEXT ctx;
 487     WCHAR source_id_str[11];
 488     static const WCHAR fmt[] = {'%','d',0};
 489     DWORD index;
 490
 491     TRACE("%p, %d, %d, %p, %ld, %p\n", hinf, source_id, info, buffer, buffer_size,
 492           required_size);
 493
 494     swprintf( source_id_str, ARRAY_SIZE(source_id_str), fmt, source_id );
 495
 496     if (!SetupFindFirstLineW( hinf, source_disks_names_platform, source_id_str, &ctx ) &&
 497         !SetupFindFirstLineW( hinf, source_disks_names, source_id_str, &ctx ))
 498         return FALSE;
 499
 500     switch (info)
 501     {
 502     case SRCINFO_PATH:          index = 4; break;
 503     case SRCINFO_TAGFILE:       index = 2; break;
 504     case SRCINFO_DESCRIPTION:   index = 1; break;
 505     default:
 506         WARN("unknown info level: %d\n", info);
 507         return FALSE;
 508     }
 509
 510     if (SetupGetStringFieldW( &ctx, index, buffer, buffer_size, required_size ))
 511         return TRUE;
 512
 513     if (required_size) *required_size = 1;
 514     if (buffer)
 515     {
 516         if (buffer_size >= 1) buffer[0] = 0;
 517         else
 518         {
 519             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 520             return FALSE;
 521         }
 522     }
 523     return TRUE;
 524 }
 525
 526 /***********************************************************************
 527  *            SetupGetTargetPathA   (SETUPAPI.@)
 528  */
 529
 530 BOOL WINAPI SetupGetTargetPathA( HINF hinf, PINFCONTEXT context, PCSTR section, PSTR buffer,
 531                                  DWORD buffer_size, PDWORD required_size )
 532 {
 533     BOOL ret = FALSE;
 534     WCHAR *sectionW = NULL, *bufferW = NULL;
 535     DWORD required;
 536     INT size;
 537
 538     TRACE("%p, %p, %s, %p, 0x%08lx, %p\n", hinf, context, debugstr_a(section), buffer,
 539           buffer_size, required_size);
 540
 541     if (section && !(sectionW = strdupAtoW( section )))
 542         return FALSE;
 543
 544     if (!SetupGetTargetPathW( hinf, context, sectionW, NULL, 0, &required ))
 545         goto done;
 546
 547     if (!(bufferW = malloc( required * sizeof(WCHAR) )))
 548         goto done;
 549
 550     if (!SetupGetTargetPathW( hinf, context, sectionW, bufferW, required, NULL ))
 551         goto done;
 552
 553     size = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
 554     if (required_size) *required_size = size;
 555
 556     if (buffer)
 557     {
 558         if (buffer_size >= size)
 559             WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, buffer_size, NULL, NULL );
 560         else
 561         {
 562             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 563             goto done;
 564         }
 565     }
 566     ret = TRUE;
 567
 568  done:
 569     free( sectionW );
 570     free( bufferW );
 571     return ret;
 572 }
 573
 574 /***********************************************************************
 575  *            SetupGetTargetPathW   (SETUPAPI.@)
 576  */
 577
 578 BOOL WINAPI SetupGetTargetPathW( HINF hinf, PINFCONTEXT context, PCWSTR section, PWSTR buffer,
 579                                  DWORD buffer_size, PDWORD required_size )
 580 {
 581     static const WCHAR destination_dirs[] =
 582         {'D','e','s','t','i','n','a','t','i','o','n','D','i','r','s',0};
 583     static const WCHAR default_dest_dir[]  =
 584         {'D','e','f','a','u','l','t','D','e','s','t','D','i','r',0};
 585
 586     INFCONTEXT ctx;
 587     WCHAR *dir, systemdir[MAX_PATH];
 588     unsigned int size;
 589     BOOL ret = FALSE;
 590
 591     TRACE("%p, %p, %s, %p, 0x%08lx, %p\n", hinf, context, debugstr_w(section), buffer,
 592           buffer_size, required_size);
 593
 594     if (context) ret = SetupFindFirstLineW( hinf, destination_dirs, NULL, context );
 595     else if (section)
 596     {
 597         if (!(ret = SetupFindFirstLineW( hinf, destination_dirs, section, &ctx )))
 598             ret = SetupFindFirstLineW( hinf, destination_dirs, default_dest_dir, &ctx );
 599     }
 600     if (!ret || !(dir = PARSER_get_dest_dir( context ? context : &ctx )))
 601     {
 602         GetSystemDirectoryW( systemdir, MAX_PATH );
 603         dir = systemdir;
 604     }
 605     size = lstrlenW( dir ) + 1;
 606     if (required_size) *required_size = size;
 607
 608     if (buffer)
 609     {
 610         if (buffer_size >= size)
 611             lstrcpyW( buffer, dir );
 612         else
 613         {
 614             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 615             if (dir != systemdir) free( dir );
 616             return FALSE;
 617         }
 618     }
 619     if (dir != systemdir) free( dir );
 620     return TRUE;
 621 }
 622
 623 /***********************************************************************
 624  *            SetupQueryInfOriginalFileInformationA   (SETUPAPI.@)
 625  */
 626 BOOL WINAPI SetupQueryInfOriginalFileInformationA(
 627     PSP_INF_INFORMATION InfInformation, UINT InfIndex,
 628     PSP_ALTPLATFORM_INFO AlternativePlatformInfo,
 629     PSP_ORIGINAL_FILE_INFO_A OriginalFileInfo)
 630 {
 631     BOOL ret;
 632     SP_ORIGINAL_FILE_INFO_W OriginalFileInfoW;
 633
 634     TRACE("(%p, %d, %p, %p)\n", InfInformation, InfIndex,
 635         AlternativePlatformInfo, OriginalFileInfo);
 636
 637     if (OriginalFileInfo->cbSize != sizeof(*OriginalFileInfo))
 638     {
 639         WARN("incorrect OriginalFileInfo->cbSize of %ld\n", OriginalFileInfo->cbSize);
 640         SetLastError( ERROR_INVALID_USER_BUFFER );
 641         return FALSE;
 642     }
 643
 644     OriginalFileInfoW.cbSize = sizeof(OriginalFileInfoW);
 645     ret = SetupQueryInfOriginalFileInformationW(InfInformation, InfIndex,
 646         AlternativePlatformInfo, &OriginalFileInfoW);
 647     if (ret)
 648     {
 649         WideCharToMultiByte(CP_ACP, 0, OriginalFileInfoW.OriginalInfName, -1,
 650             OriginalFileInfo->OriginalInfName, MAX_PATH, NULL, NULL);
 651         WideCharToMultiByte(CP_ACP, 0, OriginalFileInfoW.OriginalCatalogName, -1,
 652             OriginalFileInfo->OriginalCatalogName, MAX_PATH, NULL, NULL);
 653     }
 654
 655     return ret;
 656 }
 657
 658 /***********************************************************************
 659  *            SetupQueryInfOriginalFileInformationW   (SETUPAPI.@)
 660  */
 661 BOOL WINAPI SetupQueryInfOriginalFileInformationW(
 662     PSP_INF_INFORMATION InfInformation, UINT InfIndex,
 663     PSP_ALTPLATFORM_INFO AlternativePlatformInfo,
 664     PSP_ORIGINAL_FILE_INFO_W OriginalFileInfo)
 665 {
 666     LPCWSTR inf_name;
 667     LPCWSTR inf_path;
 668     HINF hinf;
 669     static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
 670     static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
 671
 672     FIXME("(%p, %d, %p, %p): semi-stub\n", InfInformation, InfIndex,
 673         AlternativePlatformInfo, OriginalFileInfo);
 674
 675     if (OriginalFileInfo->cbSize != sizeof(*OriginalFileInfo))
 676     {
 677         WARN("incorrect OriginalFileInfo->cbSize of %ld\n", OriginalFileInfo->cbSize);
 678         SetLastError(ERROR_INVALID_USER_BUFFER);
 679         return FALSE;
 680     }
 681
 682     inf_path = (LPWSTR)InfInformation->VersionData;
 683
 684     /* FIXME: we should get OriginalCatalogName from CatalogFile line in
 685      * the original inf file and cache it, but that would require building a
 686      * .pnf file. */
 687     hinf = SetupOpenInfFileW(inf_path, NULL, INF_STYLE_WIN4, NULL);
 688     if (hinf == INVALID_HANDLE_VALUE) return FALSE;
 689
 690     if (!SetupGetLineTextW(NULL, hinf, wszVersion, wszCatalogFile,
 691                            OriginalFileInfo->OriginalCatalogName,
 692                            ARRAY_SIZE(OriginalFileInfo->OriginalCatalogName), NULL))
 693     {
 694         OriginalFileInfo->OriginalCatalogName[0] = '\0';
 695     }
 696     SetupCloseInfFile(hinf);
 697
 698     /* FIXME: not quite correct as we just return the same file name as
 699      * destination (copied) inf file, not the source (original) inf file.
 700      * to fix it properly would require building a .pnf file */
 701     /* file name is stored in VersionData field of InfInformation */
 702     inf_name = wcsrchr(inf_path, '\\');
 703     if (inf_name) inf_name++;
 704     else inf_name = inf_path;
 705
 706     lstrcpyW(OriginalFileInfo->OriginalInfName, inf_name);
 707
 708     return TRUE;
 709 }
 710
 711 /***********************************************************************
 712  *      SetupGetInfDriverStoreLocationW (SETUPAPI.@)
 713  */
 714 BOOL WINAPI SetupGetInfDriverStoreLocationW(
 715     PCWSTR FileName, PSP_ALTPLATFORM_INFO AlternativePlatformInfo,
 716     PCWSTR LocaleName, PWSTR ReturnBuffer, DWORD ReturnBufferSize,
 717     PDWORD RequiredSize)
 718 {
 719     FIXME("stub: %s %p %s %p %lu %p\n", debugstr_w(FileName), AlternativePlatformInfo, debugstr_w(LocaleName), ReturnBuffer, ReturnBufferSize, RequiredSize);
 720
 721     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 722     return FALSE;
 723 }
 724
 725 BOOL WINAPI SetupQueryInfVersionInformationA(SP_INF_INFORMATION *info, UINT index, const char *key, char *buff,
 726     DWORD size, DWORD *req_size)
 727 {
 728     FIXME("info %p, index %d, key %s, buff %p, size %ld, req_size %p stub!\n", info, index, debugstr_a(key), buff,
 729         size, req_size);
 730     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 731     return FALSE;
 732 }
 733
 734 BOOL WINAPI SetupQueryInfVersionInformationW(SP_INF_INFORMATION *info, UINT index, const WCHAR *key, WCHAR *buff,
 735     DWORD size, DWORD *req_size)
 736 {
 737     FIXME("info %p, index %d, key %s, buff %p, size %ld, req_size %p stub!\n", info, index, debugstr_w(key), buff,
 738         size, req_size);
 739     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 740     return FALSE;
 741 }