Почему EnumPrintersA и EnumPrintersW запрашивают одинаковый объем памяти?

Сначала я думал, что с вашим кодом что-то не так, поэтому я продолжал искать ошибку (введенную FFI или же JS слои, или опечатка или что-то подобное), но я не мог ничего найти.

Тогда я начал писать программу, похожую на вашу в С (чтобы устранить любые дополнительные слои, которые могут привести к ошибкам). Вот:

#include <stdio.h>
#include <Windows.h>
#include <conio.h>typedef BOOL (__stdcall *EnumPrintersAFuncPtr)(_In_ DWORD Flags, _In_ LPSTR Name, _In_ DWORD Level, _Out_ LPBYTE pPrinterEnum, _In_ DWORD cbBuf, _Out_ LPDWORD pcbNeeded, _Out_ LPDWORD pcReturned);
typedef BOOL (__stdcall *EnumPrintersWFuncPtr)(_In_ DWORD Flags, _In_ LPWSTR Name, _In_ DWORD Level, _Out_ LPBYTE pPrinterEnum, _In_ DWORD cbBuf, _Out_ LPDWORD pcbNeeded, _Out_ LPDWORD pcReturned);void testFunc() {
PPRINTER_INFO_4A ppi4a = NULL;
PPRINTER_INFO_4W ppi4w = NULL;
BOOL resa, resw;
DWORD neededa = 0, returneda = 0, neededw = 0, returnedw = 0, gle = 0, i = 0, flags = PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS;
LPBYTE bufa = NULL, bufw = NULL;
resa = EnumPrintersA(flags, NULL, 4, NULL, 0, &neededa, &returneda);
if (resa) {
printf("EnumPrintersA(1) succeeded with NULL buffer. Exiting...\n");
return;
} else {
gle = GetLastError();
if (gle != ERROR_INSUFFICIENT_BUFFER) {
printf("EnumPrintersA(1) failed with %d(0x%08X) which is different than %d. Exiting...\n", gle, gle, ERROR_INSUFFICIENT_BUFFER);
return;
} else {
printf("EnumPrintersA(1) needs a %d(0x%08X) bytes long buffer.\n", neededa, neededa);
}
}
resw = EnumPrintersW(flags, NULL, 4, NULL, 0, &neededw, &returnedw);
if (resw) {
printf("EnumPrintersW(1) succeeded with NULL buffer. Exiting...\n");
return;
} else {
gle = GetLastError();
if (gle != ERROR_INSUFFICIENT_BUFFER) {
printf("EnumPrintersW(1) failed with %d(0x%08X) which is different than %d. Exiting...\n", gle, gle, ERROR_INSUFFICIENT_BUFFER);
return;
} else {
printf("EnumPrintersW(1) needs a %d(0x%08X) bytes long buffer.\n", neededw, neededw);
}
}

bufa = (LPBYTE)calloc(1, neededa);
if (bufa == NULL) {
printf("calloc failed with %d(0x%08X). Exiting...\n", errno, errno);
return;
} else {
printf("buffera[0x%08X:0x%08X]\n", (long)bufa, (long)bufa + neededa - 1);
}
bufw = (LPBYTE)calloc(1, neededw);
if (bufw == NULL) {
printf("calloc failed with %d(0x%08X). Exiting...\n", errno, errno);
free(bufa);
return;
} else {
printf("bufferw[0x%08X:0x%08X]\n", (long)bufw, (long)bufw + neededw - 1);
}

resa = EnumPrintersA(flags, NULL, 4, bufa, neededa, &neededa, &returneda);
if (!resa) {
gle = GetLastError();
printf("EnumPrintersA(2) failed with %d(0x%08X). Exiting...\n", gle, gle);
free(bufa);
free(bufw);
return;
}
printf("EnumPrintersA(2) copied %d bytes in the buffer out of which the first %d(0x%08X) represent %d structures of size %d\n", neededa, returneda * sizeof(PRINTER_INFO_4A), returneda * sizeof(PRINTER_INFO_4A), returneda, sizeof(PRINTER_INFO_4A));
resw = EnumPrintersW(flags, NULL, 4, bufw, neededw, &neededw, &returnedw);
if (!resw) {
gle = GetLastError();
printf("EnumPrintersW(2) failed with %d(0x%08X). Exiting...\n", gle, gle);
free(bufw);
free(bufa);
return;
}
printf("EnumPrintersW(2) copied %d bytes in the buffer out of which the first %d(0x%08X) represent %d structures of size %d\n", neededw, returnedw * sizeof(PRINTER_INFO_4W), returnedw * sizeof(PRINTER_INFO_4W), returnedw, sizeof(PRINTER_INFO_4W));

ppi4a = (PPRINTER_INFO_4A)bufa;
ppi4w = (PPRINTER_INFO_4W)bufw;
printf("\nPrinting ASCII results:\n");
for (i = 0; i < returneda; i++) {
printf("  Item %d\n    pPrinterName: [%s]\n", i, ppi4a[i].pPrinterName ? ppi4a[i].pPrinterName : "NULL");
}
printf("\nPrinting WIDE results:\n");
for (i = 0; i < returnedw; i++) {
wprintf(L"  Item %d\n    pPrinterName: [%s]\n", i, ppi4w[i].pPrinterName ? ppi4w[i].pPrinterName : L"NULL");
}

free(bufa);
free(bufw);
}int main() {
testFunc();
printf("\nPress a key to exit...\n");
getch();
return 0;
}

Заметка: с точки зрения имен переменных (я держал их краткими — и, следовательно, не очень интуитивно понятным), или же вес в конце их имен означает, что они используются для ASCII / ШИРОКИЙ версия.

Сначала я боялась, что EnumPrinters может ничего не возвращать, так как на данный момент я не подключен ни к какому принтеру, но, к счастью, у меня есть некоторые (7, если быть более точными) «сохраненные». Вот выходные данные вышеупомянутой программы (спасибо @qxz за исправление моей первоначальной (и отчасти ошибочной) версии):

EnumPrintersA(1) needs a 544(0x00000220) bytes long buffer.
EnumPrintersW(1) needs a 544(0x00000220) bytes long buffer.
buffera[0x03161B20:0x03161D3F]
bufferw[0x03165028:0x03165247]
EnumPrintersA(2) copied 544 bytes in the buffer out of which the first 84(0x00000054) represent 7 structures of size 12
EnumPrintersW(2) copied 544 bytes in the buffer out of which the first 84(0x00000054) represent 7 structures of size 12

Printing ASCII results:
Item 0
pPrinterName: [Send To OneNote 2013]
Item 1
pPrinterName: [NPI060BEF (HP LaserJet Professional M1217nfw MFP)]
Item 2
pPrinterName: [Microsoft XPS Document Writer]
Item 3
pPrinterName: [Microsoft Print to PDF]
Item 4
pPrinterName: [HP Universal Printing PCL 6]
Item 5
pPrinterName: [HP LaserJet M4345 MFP [7B63B6]]
Item 6
pPrinterName: [Fax]

Printing WIDE results:
Item 0
pPrinterName: [Send To OneNote 2013]
Item 1
pPrinterName: [NPI060BEF (HP LaserJet Professional M1217nfw MFP)]
Item 2
pPrinterName: [Microsoft XPS Document Writer]
Item 3
pPrinterName: [Microsoft Print to PDF]
Item 4
pPrinterName: [HP Universal Printing PCL 6]
Item 5
pPrinterName: [HP LaserJet M4345 MFP [7B63B6]]
Item 6
pPrinterName: [Fax]

Press a key to exit...

удивительно (по крайней мере для меня), поведение, которое вы описали, может быть воспроизведено.

Заметка что приведенный выше вывод получен из 32-битной скомпилированной версии программы (64-битные указатели труднее читать :)), но поведение воспроизводимо и при компиляции для 64-битной (я использую VStudio 10.0 на Win10).

Поскольку в конце буфера наверняка есть строки, я начал отладку:

Выше картина VStudio 10.0 Окно отладки, с программой, прерванной в конце testFuncперед освобождением 1-го указателя. Теперь я не знаю, насколько вы знакомы с отладкой на VStudio, так что я собираюсь пройти через (соответствующие) области окна:

• внизу есть 2 Часы окна (используется для отображения переменных во время работы программы). Как видно, переменная название, Значение а также Тип отображаются.
  • справа (Смотреть 1): 1-я (0-я) и последняя (6-я — из 7) структур в начале каждого из 2 буферов.
  • слева (Смотреть 2): адреса 2 буферов.
• выше Часы окна (Память 2) это содержимое памяти для bufw, объем памяти Окно содержит ряд строк, и в каждой строке есть адрес памяти (выделен серым цветом слева), за которым следует его содержимое в наговор (каждый байт соответствует 2 наговор цифры — например, 1E), то справа то же содержание в голец представление (каждый байт соответствует 1 символу — я собираюсь вернуться к этому), затем следующий ряд и так далее.
• выше Память 2 (Память 1): это содержимое памяти для bufa,

Теперь вернемся к макету памяти: не все символы справа — это то, чем они кажутся, некоторые из них просто отображаются для удобства чтения. Например, есть много точек (.) на правой стороне, но они не все точки. Если вы ищете точку на соответствующем наговор представление вы заметите, что для многих из них это 00 или же NULL (это непечатаемый символ, но он отображается в виде точки).

Что касается содержимого буфера каждого из 2 объем памяти окна (глядя на представление char), есть 3 зоны:

• PRINTER_INFO_4* зона или тарабарщина в начале: 544 байта, соответствующих приблизительно первым 3 строкам
• странные символы из последних ~ 1,5 строк: они находятся вне наших буферов, поэтому мы не заботимся о них
• средняя зона: где хранятся струны

Давайте посмотрим на ШИРОКИЙ Струнная зона (Память 2 — средняя зона): как вы упомянули, у каждого персонажа есть 2 байта: потому что в моем случае они все ASCII очаровывает MSB (или кодовая byte) всегда равен 0 (поэтому вы видите чередование символов и точек: например, «.L.a.s.e.r.J.e.t» в строке 4).

Поскольку в буфере есть несколько строк (или, если хотите, строка) — или даже лучше: несколько TCHAR*в TCHAR* — они должны быть отделены: это делается NULL ШИРОКИЙ char (hex: 00 00, голец ..) в конце каждой строки; в сочетании с тем, что 1-й символ первой строки следующей строки также 00 (.), вы увидите последовательность из 3 NULL байт (шестнадцатеричный: 00 00 00, голец: …) и это разделитель между 2 (ШИРОКИЙ) струны в средней зоне.

Теперь, сравнивая 2 средние части (соответствующие 2 буферам), вы заметите, что разделители строк точно в тех же позициях и больше: последние части каждой строки одинаковы (последние половины каждой строки, чтобы быть более точным).

Учитывая это, вот моя теория:

Я думаю EnumPrintersA звонки EnumPrintersWи затем он перебирает каждую из строк (в конце буфера) и вызывает wcstombs или даже лучше: WideCharToMultiByte на них (преобразование их на месте — и, следовательно, в результате ASCII Строка занимает только 1-ю половину ШИРОКИЙ строка, оставляя 2-ую половину неизменной), без преобразования всего буфера. Я должен проверить это, посмотрев с дизассемблером в WINSPOOL.DRV.

Лично (если я прав) я думаю, что это неудачный обходной путь (или gainarie как мне нравится это называть) но кто знает может быть все * A, * W пары функций (по крайней мере, те, кто возвращает несколько char* в char*) работать так. В любом случае, есть и плюсы для этого подхода (по крайней мере, для этих двух функций):

• DEV-накрест — нормально, что одна функция вызывает другую и сохраняет реализацию в 1 месте (вместо дублирования в обеих функциях).
• С точки зрения производительности — это нормально, чтобы не воссоздавать буфер, так как это
  подразумевать дополнительные вычисления; в конце концов, потребитель буфера обычно не достигает второй половины каждого ASCII строка в буфере.