[CONSRV]: Use NtDuplicateObject with DUPLICATE_CLOSE_SOURCE to close a duplicated...
[reactos.git] / reactos / win32ss / user / winsrv / consrv / condrv / graphics.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Console Driver DLL
4 * FILE: win32ss/user/winsrv/consrv/condrv/graphics.c
5 * PURPOSE: Console Output Functions for graphics-mode screen-buffers
6 * PROGRAMMERS: Hermes Belusca-Maito (hermes.belusca@sfr.fr)
7 *
8 * NOTE: See http://blog.airesoft.co.uk/2012/10/things-ms-can-do-that-they-dont-tell-you-about-console-graphics/
9 * for more information.
10 */
11
12 /* INCLUDES *******************************************************************/
13
14 #include <consrv.h>
15
16 #define NDEBUG
17 #include <debug.h>
18
19 /* PRIVATE FUNCTIONS **********************************************************/
20
21 CONSOLE_IO_OBJECT_TYPE
22 GRAPHICS_BUFFER_GetType(PCONSOLE_SCREEN_BUFFER This)
23 {
24 // return This->Header.Type;
25 return GRAPHICS_BUFFER;
26 }
27
28 static CONSOLE_SCREEN_BUFFER_VTBL GraphicsVtbl =
29 {
30 GRAPHICS_BUFFER_GetType,
31 };
32
33
34 NTSTATUS
35 CONSOLE_SCREEN_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
36 IN PCONSOLE Console,
37 IN PCONSOLE_SCREEN_BUFFER_VTBL Vtbl,
38 IN SIZE_T Size);
39 VOID
40 CONSOLE_SCREEN_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer);
41
42
43 NTSTATUS
44 GRAPHICS_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
45 IN PCONSOLE Console,
46 IN HANDLE ProcessHandle,
47 IN PGRAPHICS_BUFFER_INFO GraphicsInfo)
48 {
49 NTSTATUS Status = STATUS_SUCCESS;
50 PGRAPHICS_SCREEN_BUFFER NewBuffer = NULL;
51
52 LARGE_INTEGER SectionSize;
53 ULONG ViewSize = 0;
54
55 if (Buffer == NULL || Console == NULL || GraphicsInfo == NULL)
56 return STATUS_INVALID_PARAMETER;
57
58 *Buffer = NULL;
59
60 Status = CONSOLE_SCREEN_BUFFER_Initialize((PCONSOLE_SCREEN_BUFFER*)&NewBuffer,
61 Console,
62 &GraphicsVtbl,
63 sizeof(GRAPHICS_SCREEN_BUFFER));
64 if (!NT_SUCCESS(Status)) return Status;
65 NewBuffer->Header.Type = GRAPHICS_BUFFER;
66
67 /*
68 * Remember the handle to the process so that we can close or unmap
69 * correctly the allocated resources when the client releases the
70 * screen buffer.
71 */
72 NewBuffer->ClientProcess = ProcessHandle;
73
74 /* Get infos from the graphics buffer information structure */
75 NewBuffer->BitMapInfoLength = GraphicsInfo->Info.dwBitMapInfoLength;
76
77 NewBuffer->BitMapInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, NewBuffer->BitMapInfoLength);
78 if (NewBuffer->BitMapInfo == NULL)
79 {
80 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
81 return STATUS_INSUFFICIENT_RESOURCES;
82 }
83
84 /* Adjust the bitmap height if needed (bottom-top vs. top-bottom). Use always bottom-up. */
85 if (GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight > 0)
86 GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight = -GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight;
87
88 /* We do not use anything else than uncompressed bitmaps */
89 if (GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression != BI_RGB)
90 {
91 DPRINT1("biCompression == %d != BI_RGB, fix that!\n",
92 GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression);
93 GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression = BI_RGB;
94 }
95
96 RtlCopyMemory(NewBuffer->BitMapInfo,
97 GraphicsInfo->Info.lpBitMapInfo,
98 GraphicsInfo->Info.dwBitMapInfoLength);
99
100 NewBuffer->BitMapUsage = GraphicsInfo->Info.dwUsage;
101
102 /* Set the screen buffer size. Fight against overflows. */
103 if ( GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biWidth <= 0xFFFF &&
104 -GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight <= 0xFFFF )
105 {
106 /* Be careful about the sign of biHeight */
107 NewBuffer->ScreenBufferSize.X = (SHORT)GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biWidth ;
108 NewBuffer->ScreenBufferSize.Y = (SHORT)-GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight;
109
110 NewBuffer->OldViewSize = NewBuffer->ViewSize =
111 NewBuffer->OldScreenBufferSize = NewBuffer->ScreenBufferSize;
112 }
113 else
114 {
115 Status = STATUS_INSUFFICIENT_RESOURCES;
116 ConsoleFreeHeap(NewBuffer->BitMapInfo);
117 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
118 goto Quit;
119 }
120
121 /*
122 * Create a mutex to synchronize bitmap memory access
123 * between ourselves and the client.
124 */
125 Status = NtCreateMutant(&NewBuffer->Mutex, MUTANT_ALL_ACCESS, NULL, FALSE);
126 if (!NT_SUCCESS(Status))
127 {
128 DPRINT1("NtCreateMutant() failed: %lu\n", Status);
129 ConsoleFreeHeap(NewBuffer->BitMapInfo);
130 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
131 goto Quit;
132 }
133
134 /*
135 * Duplicate the Mutex for the client. We must keep a trace of it
136 * so that we can close it when the client releases the screen buffer.
137 */
138 Status = NtDuplicateObject(NtCurrentProcess(),
139 NewBuffer->Mutex,
140 ProcessHandle,
141 &NewBuffer->ClientMutex,
142 0, 0, DUPLICATE_SAME_ACCESS);
143 if (!NT_SUCCESS(Status))
144 {
145 DPRINT1("NtDuplicateObject() failed: %lu\n", Status);
146 NtClose(NewBuffer->Mutex);
147 ConsoleFreeHeap(NewBuffer->BitMapInfo);
148 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
149 goto Quit;
150 }
151
152 /*
153 * Create a memory section for the bitmap area, to share with the client.
154 */
155 SectionSize.QuadPart = NewBuffer->BitMapInfo->bmiHeader.biSizeImage;
156 Status = NtCreateSection(&NewBuffer->hSection,
157 SECTION_ALL_ACCESS,
158 NULL,
159 &SectionSize,
160 PAGE_READWRITE,
161 SEC_COMMIT,
162 NULL);
163 if (!NT_SUCCESS(Status))
164 {
165 DPRINT1("Error: Impossible to create a shared section, Status = 0x%08lx\n", Status);
166 NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
167 NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
168 NtClose(NewBuffer->Mutex);
169 ConsoleFreeHeap(NewBuffer->BitMapInfo);
170 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
171 goto Quit;
172 }
173
174 /*
175 * Create a view for our needs.
176 */
177 ViewSize = 0;
178 NewBuffer->BitMap = NULL;
179 Status = NtMapViewOfSection(NewBuffer->hSection,
180 NtCurrentProcess(),
181 (PVOID*)&NewBuffer->BitMap,
182 0,
183 0,
184 NULL,
185 &ViewSize,
186 ViewUnmap,
187 0,
188 PAGE_READWRITE);
189 if (!NT_SUCCESS(Status))
190 {
191 DPRINT1("Error: Impossible to map the shared section, Status = 0x%08lx\n", Status);
192 NtClose(NewBuffer->hSection);
193 NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
194 NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
195 NtClose(NewBuffer->Mutex);
196 ConsoleFreeHeap(NewBuffer->BitMapInfo);
197 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
198 goto Quit;
199 }
200
201 /*
202 * Create a view for the client. We must keep a trace of it so that
203 * we can unmap it when the client releases the screen buffer.
204 */
205 ViewSize = 0;
206 NewBuffer->ClientBitMap = NULL;
207 Status = NtMapViewOfSection(NewBuffer->hSection,
208 ProcessHandle,
209 (PVOID*)&NewBuffer->ClientBitMap,
210 0,
211 0,
212 NULL,
213 &ViewSize,
214 ViewUnmap,
215 0,
216 PAGE_READWRITE);
217 if (!NT_SUCCESS(Status))
218 {
219 DPRINT1("Error: Impossible to map the shared section, Status = 0x%08lx\n", Status);
220 NtUnmapViewOfSection(NtCurrentProcess(), NewBuffer->BitMap);
221 NtClose(NewBuffer->hSection);
222 NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
223 NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
224 NtClose(NewBuffer->Mutex);
225 ConsoleFreeHeap(NewBuffer->BitMapInfo);
226 CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
227 goto Quit;
228 }
229
230 NewBuffer->ViewOrigin.X = NewBuffer->ViewOrigin.Y = 0;
231 NewBuffer->VirtualY = 0;
232
233 NewBuffer->CursorBlinkOn = FALSE;
234 NewBuffer->ForceCursorOff = TRUE;
235 NewBuffer->CursorInfo.bVisible = FALSE;
236 NewBuffer->CursorInfo.dwSize = 0;
237 NewBuffer->CursorPosition.X = NewBuffer->CursorPosition.Y = 0;
238
239 NewBuffer->Mode = 0;
240
241 *Buffer = (PCONSOLE_SCREEN_BUFFER)NewBuffer;
242 Status = STATUS_SUCCESS;
243
244 Quit:
245 return Status;
246 }
247
248 VOID
249 GRAPHICS_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
250 {
251 PGRAPHICS_SCREEN_BUFFER Buff = (PGRAPHICS_SCREEN_BUFFER)Buffer;
252
253 /*
254 * IMPORTANT !! Reinitialize the type so that we don't enter a recursive
255 * infinite loop when calling CONSOLE_SCREEN_BUFFER_Destroy.
256 */
257 Buffer->Header.Type = SCREEN_BUFFER;
258
259 /*
260 * Uninitialize the graphics screen buffer
261 * in the reverse way we initialized it.
262 */
263 NtUnmapViewOfSection(Buff->ClientProcess, Buff->ClientBitMap);
264 NtUnmapViewOfSection(NtCurrentProcess(), Buff->BitMap);
265 NtClose(Buff->hSection);
266 NtDuplicateObject(Buff->ClientProcess, Buff->ClientMutex,
267 NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
268 NtClose(Buff->Mutex);
269 ConsoleFreeHeap(Buff->BitMapInfo);
270
271 CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
272 }
273
274 /* EOF */