1 /*
2 Copyright (C) 2015-2021, Dirk Krause
3 SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 WARNING: This file was generated by the dkct program (see
8 http://dktools.sourceforge.net/ for details).
9 Changes you make here will be lost if dkct is run again!
10 You should modify the original source and run dkct on it.
11 Original source: dk4wreg8.ctr
12 */
13
14 /** @file dk4wreg8.c The dk4wreg8 module.
15 */
16
17
18 #include "dk4conf.h"
19 #include <libdk4c/dk4wregt.h>
20 #include <libdk4c/dk4wreg8.h>
21 #ifndef DK4MEM_H_INCLUDED
22 #include <libdk4base/dk4mem.h>
23 #endif
24 #include <libdk4ma/dk4maasz.h>
25
26 #if DK4_ON_WINDOWS
27
28 #ifndef WINDOWS_H_INCLUDED
29 #include <windows.h>
30 #define WINDOWS_H_INCLUDED 1
31 #endif
32 #ifndef WINBASE_H_INCLUDED
33 #include <winbase.h>
34 #define WINBASE_H_INCLUDED 1
35 #endif
36 #ifndef WINREG_H_INCLUDED
37 #include <winreg.h>
38 #define WINREG_H_INCLUDED 1
39 #endif
40
41 #endif
42
43 #ifndef DK4STR8_H_INCLUDED
44 #include <libdk4base/dk4str8.h>
45 #endif
46
47 #include <libdk4base/dk4unused.h>
48
49 #if DK4_HAVE_ASSERT_H
50 #ifndef ASSERT_H_INCLUDED
51 #include <assert.h>
52 #define ASSERT_H_INCLUDED 1
53 #endif
54 #endif
55
56
57
58
59
60
61 void *
dk4wreg_open_key_c8(int pk,const char * keyname,int wr,dk4_er_t * erp)62 dk4wreg_open_key_c8(
63 #if DK4_ON_WINDOWS
64 int pk,
65 const char *keyname,
66 int wr,
67 #else
68 int DK4_ARG_UNUSED(pk),
69 const char * DK4_ARG_UNUSED(keyname),
70 int DK4_ARG_UNUSED(wr),
71 #endif
72 dk4_er_t *erp
73 )
74 {
75 #if DK4_ON_WINDOWS
76 dk4_wreg_key_t *back = NULL;
77 HKEY park = HKEY_LOCAL_MACHINE;
78 LONG res;
79 DWORD disp;
80 #if DK4_USE_ASSERT
81 assert(NULL != keyname);
82 #endif
83 if (NULL != keyname) {
84 switch (pk) {
85 case DK4_WREGKEY_HKLM:
86 case DK4_WREGKEY_HKCU:
87 case DK4_WREGKEY_HKCL:
88 case DK4_WREGKEY_KHUS:
89 case DK4_WREGKEY_HKCC: {
90 switch (pk) {
91 case DK4_WREGKEY_HKLM: {
92 park = HKEY_LOCAL_MACHINE;
93 } break;
94 case DK4_WREGKEY_HKCU: {
95 park = HKEY_CURRENT_USER;
96 } break;
97 case DK4_WREGKEY_HKCL: {
98 park = HKEY_CLASSES_ROOT;
99 } break;
100 case DK4_WREGKEY_KHUS: {
101 park = HKEY_USERS;
102 } break;
103 case DK4_WREGKEY_HKCC: {
104 park = HKEY_CURRENT_CONFIG;
105 } break;
106 }
107 back = dk4mem_new(dk4_wreg_key_t,1,erp);
108 if (NULL != back) {
109 res = RegCreateKeyExA(
110 park,
111 keyname,
112 (DWORD)0,
113 NULL,
114 REG_OPTION_NON_VOLATILE,
115 ((0 != wr) ? (KEY_ALL_ACCESS) : (KEY_READ)),
116 NULL,
117 &(back->hk),
118 &disp
119 );
120 if (ERROR_SUCCESS != res) {
121 dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND);
122 dk4mem_free(back);
123 back = NULL;
124 }
125 }
126 } break;
127 default: {
128 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
129 } break;
130 }
131 } else {
132 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
133 }
134 return ((void *)back);
135 #else
136 DK4_UNUSED_ARG(pk)
137 DK4_UNUSED_ARG(keyname)
138 DK4_UNUSED_ARG(wr)
139 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
140 return NULL;
141 #endif
142 }
143
144
145
146 int
dk4wreg_set_string_c8(void * kptr,const char * name,const char * val,int expand,dk4_er_t * erp)147 dk4wreg_set_string_c8(
148 #if DK4_ON_WINDOWS
149 void *kptr,
150 const char *name,
151 const char *val,
152 int expand,
153 #else
154 void * DK4_ARG_UNUSED(kptr),
155 const char * DK4_ARG_UNUSED(name),
156 const char * DK4_ARG_UNUSED(val),
157 int DK4_ARG_UNUSED(expand),
158 #endif
159 dk4_er_t *erp
160 )
161 {
162 #if DK4_ON_WINDOWS
163 dk4_er_t er;
164 dk4_wreg_key_t *hptr;
165 int back = 0;
166 size_t lgt;
167 DWORD dwt = REG_SZ;
168 DWORD dw0 = (DWORD)0UL;
169 DWORD sz;
170 LONG res;
171 #if DK4_USE_ASSERT
172 assert(NULL != kptr);
173 assert(NULL != name);
174 assert(NULL != val);
175 #endif
176 if ((NULL != kptr) && (NULL != val)) {
177 if (0 != expand) { dwt = REG_EXPAND_SZ; }
178 dk4error_init(&er);
179 lgt = dk4ma_size_t_add( 1, dk4str8_len(val), &er);
180 if (DK4_E_NONE == er.ec) {
181 if ((dk4_um_t)0x7FFFFFFFUL >= (dk4_um_t)lgt) {
182 sz = (DWORD)lgt;
183 hptr = (dk4_wreg_key_t *)kptr;
184 res = RegSetValueExA(
185 hptr->hk,
186 name,
187 dw0,
188 dwt,
189 (const BYTE *)val,
190 sz
191 );
192 if (ERROR_SUCCESS == res) {
193 back = 1;
194 } else {
195 dk4error_set_ldetails(erp, DK4_E_SYSTEM, res);
196 }
197 } else {
198 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
199 }
200 } else {
201 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
202 }
203 } else {
204 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
205 }
206 return back;
207 #else
208 DK4_UNUSED_ARG(kptr)
209 DK4_UNUSED_ARG(name)
210 DK4_UNUSED_ARG(val)
211 DK4_UNUSED_ARG(expand)
212 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
213 return 0;
214 #endif
215 }
216
217
218
219 int
dk4wreg_get_string_c8(void * kptr,const char * name,char * bptr,size_t sz,int * expand,dk4_er_t * erp)220 dk4wreg_get_string_c8(
221 #if DK4_ON_WINDOWS
222 void *kptr,
223 const char *name,
224 char *bptr,
225 size_t sz,
226 int *expand,
227 #else
228 void * DK4_ARG_UNUSED(kptr),
229 const char * DK4_ARG_UNUSED(name),
230 char * DK4_ARG_UNUSED(bptr),
231 size_t DK4_ARG_UNUSED(sz),
232 int * DK4_ARG_UNUSED(expand),
233 #endif
234 dk4_er_t *erp
235 )
236 {
237 #if DK4_ON_WINDOWS
238 dk4_wreg_key_t *hptr;
239 int back = 0;
240 DWORD dwt = REG_SZ;
241 DWORD dws;
242 DWORD dwsbck;
243 LONG res;
244 #if DK4_USE_ASSERT
245 assert(NULL != kptr);
246 assert(NULL != name);
247 assert(NULL != bptr);
248 assert(0 < sz);
249 #endif
250 if ((NULL != bptr) && (0 < sz)) {
251 *bptr = '\0';
252 }
253 if ((NULL != kptr) && (NULL != name) && (NULL != bptr) && (0 < sz)) {
254 if ((dk4_um_t)0x7FFFFFFFUL >= (dk4_um_t)sz) {
255 dws = (DWORD)sz;
256 } else {
257 dws = (DWORD)0x7FFFFFFFUL;
258 }
259 dwsbck = dws;
260 hptr = (dk4_wreg_key_t *)kptr;
261 res = RegQueryValueExA(
262 hptr->hk,
263 name,
264 NULL,
265 &dwt,
266 (LPBYTE)bptr,
267 &dws
268 );
269 if (ERROR_SUCCESS == res) {
270 switch (dwt) {
271 case REG_SZ: case REG_EXPAND_SZ: {
272 if ((DWORD)0L < dws) {
273 if (dws < dwsbck) { /* dws is positive */
274 bptr[dws] = '\0';
275 } else {
276 bptr[dwsbck-1] = '\0';
277 }
278 back = 1;
279 if (REG_EXPAND_SZ == dwt) {
280 if (NULL != expand) {
281 *expand = 1;
282 }
283 }
284 } else {
285 dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND);
286 }
287 } break;
288 default: {
289 /* ERROR: Not a string */
290 dk4error_set_simple_error_code(erp, DK4_E_SYNTAX);
291 } break;
292 }
293 } else {
294 dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND);
295 }
296 } else {
297 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
298 }
299 return back;
300 #else
301 DK4_UNUSED_ARG(kptr)
302 DK4_UNUSED_ARG(name)
303 DK4_UNUSED_ARG(bptr)
304 DK4_UNUSED_ARG(sz)
305 DK4_UNUSED_ARG(expand)
306 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
307 return 0;
308 #endif
309 }
310
311
312
313 int
dk4wreg_set_dword_c8(void * kptr,const char * name,dk4_dword_t val,dk4_er_t * erp)314 dk4wreg_set_dword_c8(
315 #if DK4_ON_WINDOWS
316 void *kptr,
317 const char *name,
318 dk4_dword_t val,
319 #else
320 void * DK4_ARG_UNUSED(kptr),
321 const char * DK4_ARG_UNUSED(name),
322 dk4_dword_t DK4_ARG_UNUSED(val),
323 #endif
324 dk4_er_t *erp
325 )
326 {
327 #if DK4_ON_WINDOWS
328 dk4_wreg_key_t *hptr;
329 int back = 0;
330 DWORD dwt = REG_DWORD;
331 DWORD dws = sizeof(DWORD);
332 DWORD dw0 = (DWORD)0L;
333 LONG res;
334 #if DK4_USE_ASSERT
335 assert(NULL != kptr);
336 assert(NULL != name);
337 #endif
338 if (NULL != kptr) {
339 hptr = (dk4_wreg_key_t *)kptr;
340 res = RegSetValueExA(
341 hptr->hk,
342 name,
343 dw0,
344 dwt,
345 (const BYTE *)(&val),
346 dws
347 );
348 if (ERROR_SUCCESS == res) {
349 back = 1;
350 } else {
351 dk4error_set_ldetails(erp, DK4_E_SYSTEM, res);
352 }
353 } else {
354 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
355 }
356 return back;
357 #else
358 DK4_UNUSED_ARG(kptr)
359 DK4_UNUSED_ARG(name)
360 DK4_UNUSED_ARG(val)
361 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
362 return 0;
363 #endif
364 }
365
366
367
368 int
dk4wreg_get_dword_c8(void * kptr,const char * name,dk4_dword_t * vptr,dk4_er_t * erp)369 dk4wreg_get_dword_c8(
370 #if DK4_ON_WINDOWS
371 void *kptr,
372 const char *name,
373 dk4_dword_t *vptr,
374 #else
375 void * DK4_ARG_UNUSED(kptr),
376 const char * DK4_ARG_UNUSED(name),
377 dk4_dword_t * DK4_ARG_UNUSED(vptr),
378 #endif
379 dk4_er_t *erp
380 )
381 {
382 #if DK4_ON_WINDOWS
383 dk4_wreg_key_t *hptr;
384 int back = 0;
385 DWORD dwt = REG_DWORD;
386 DWORD dws = (DWORD)sizeof(DWORD);
387 LONG res;
388 #if DK4_USE_ASSERT
389 assert(NULL != kptr);
390 assert(NULL != name);
391 assert(NULL != vptr);
392 #endif
393 if ((NULL != kptr) && (NULL != vptr)) {
394 hptr = (dk4_wreg_key_t *)kptr;
395 res = RegQueryValueExA(
396 hptr->hk,
397 name,
398 NULL,
399 &dwt,
400 (LPBYTE)vptr,
401 &dws
402 );
403 if (ERROR_SUCCESS == res) {
404 if (REG_DWORD == dwt) {
405 if ((DWORD)sizeof(DWORD) == dws) {
406 back = 1;
407 } else {
408 dk4error_set_simple_error_code(erp, DK4_E_SYNTAX);
409 }
410 } else {
411 dk4error_set_simple_error_code(erp, DK4_E_SYNTAX);
412 }
413 } else {
414 dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND);
415 }
416 } else {
417 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
418 }
419 return back;
420 #else
421 DK4_UNUSED_ARG(kptr)
422 DK4_UNUSED_ARG(name)
423 DK4_UNUSED_ARG(vptr)
424 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
425 return 0;
426 #endif
427 }
428
429
430
431 int
dk4wreg_get_expanded_string_c8(void * kptr,const char * name,char * dptr,size_t dsz,char * b1,size_t b1sz,char * b2,size_t b2sz,dk4_er_t * erp)432 dk4wreg_get_expanded_string_c8(
433 #if DK4_ON_WINDOWS
434 void *kptr,
435 const char *name,
436 char *dptr,
437 size_t dsz,
438 char *b1,
439 size_t b1sz,
440 char *b2,
441 size_t b2sz,
442 dk4_er_t *erp
443 #else
444 void * DK4_ARG_UNUSED(kptr),
445 const char * DK4_ARG_UNUSED(name),
446 char * DK4_ARG_UNUSED(dptr),
447 size_t DK4_ARG_UNUSED(dsz),
448 char * DK4_ARG_UNUSED(b1),
449 size_t DK4_ARG_UNUSED(b1sz),
450 char * DK4_ARG_UNUSED(b2),
451 size_t DK4_ARG_UNUSED(b2sz),
452 dk4_er_t *erp
453 #endif
454 )
455 {
456 #if DK4_ON_WINDOWS
457 DWORD nc;
458 DWORD dws;
459 int expand = 0;
460 int back = 0;
461
462 #if DK4_USE_ASSERT
463 assert(NULL != kptr);
464 assert(NULL != name);
465 assert(NULL != dptr);
466 assert(0 < dsz);
467 assert(NULL != b1);
468 assert(0 < b1sz);
469 assert(NULL != b2);
470 assert(0 < b2sz);
471 #endif
472 if ((NULL != dptr) && (0 < dsz)) { *dptr = '\0'; }
473 if ((NULL != kptr) && (NULL != name) && (NULL != dptr) && (0 < dsz)) {
474 if ((NULL != b1) && (NULL != b2) && (0 < b1sz) && (2 < b2sz)) {
475 back = dk4wreg_get_string_c8(kptr, name, b1, b1sz, &expand, erp);
476 if (0 != back) {
477 if (0 != expand) {
478 if ((dk4_um_t)(0x7FFFFFFFUL) >= (dk4_um_t)b2sz) {
479 dws = (DWORD)b2sz;
480 } else {
481 dws = 0x7FFFFFFFUL;
482 }
483 dws = dws - 2;
484 nc = ExpandEnvironmentStringsA(b1, b2, dws);
485 if ((0 < nc) && (nc <= dws)) {
486 back = dk4str8_cpy_s(dptr, dsz, b2, erp);
487
488
489
490 } else {
491 dk4error_set_simple_error_code(erp, DK4_E_BUFFER_TOO_SMALL);
492 }
493 } else {
494 back = dk4str8_cpy_s(dptr, dsz, b1, erp);
495
496
497
498 }
499 } else {
500 }
501 } else {
502 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
503 }
504 } else {
505 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
506 }
507 return back;
508 #else
509 DK4_UNUSED_ARG(kptr)
510 DK4_UNUSED_ARG(name)
511 DK4_UNUSED_ARG(dptr)
512 DK4_UNUSED_ARG(dsz)
513 DK4_UNUSED_ARG(b1)
514 DK4_UNUSED_ARG(b1sz)
515 DK4_UNUSED_ARG(b2)
516 DK4_UNUSED_ARG(b2sz)
517 dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
518 return 0;
519 #endif
520 }
521
522