s3:registry: move reg_objects.h to registry/ and use it only where needed
[kai/samba.git] / source3 / rpc_server / srv_ntsvcs_nt.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *
5  *  Copyright (C) Gerald (Jerry) Carter             2005.
6  *  Copyright (C) Guenther Deschner                 2008,2009.
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 3 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include "includes.h"
23 #include "../librpc/gen_ndr/srv_ntsvcs.h"
24 #include "registry.h"
25 #include "registry/reg_objects.h"
26
27 #undef DBGC_CLASS
28 #define DBGC_CLASS DBGC_RPC_SRV
29
30 /********************************************************************
31 ********************************************************************/
32
33 static char* get_device_path(TALLOC_CTX *mem_ctx, const char *device )
34 {
35         return talloc_asprintf(mem_ctx, "ROOT\\Legacy_%s\\0000", device);
36 }
37
38 /********************************************************************
39 ********************************************************************/
40
41 WERROR _PNP_GetVersion(pipes_struct *p,
42                        struct PNP_GetVersion *r)
43 {
44         *r->out.version = 0x0400;      /* no idea what this means */
45
46         return WERR_OK;
47 }
48
49 /********************************************************************
50 ********************************************************************/
51
52 WERROR _PNP_GetDeviceListSize(pipes_struct *p,
53                               struct PNP_GetDeviceListSize *r)
54 {
55         char *devicepath;
56
57         if ((r->in.flags & CM_GETIDLIST_FILTER_SERVICE) &&
58             (!r->in.devicename)) {
59                 return WERR_CM_INVALID_POINTER;
60         }
61
62         if (!(devicepath = get_device_path(p->mem_ctx, r->in.devicename))) {
63                 return WERR_NOMEM;
64         }
65
66         *r->out.size = strlen(devicepath) + 2;
67
68         TALLOC_FREE(devicepath);
69
70         return WERR_OK;
71 }
72
73 /****************************************************************
74  _PNP_GetDeviceList
75 ****************************************************************/
76
77 WERROR _PNP_GetDeviceList(pipes_struct *p,
78                           struct PNP_GetDeviceList *r)
79 {
80         char *devicepath;
81         uint32_t size = 0;
82         const char **multi_sz = NULL;
83         DATA_BLOB blob;
84
85         if ((r->in.flags & CM_GETIDLIST_FILTER_SERVICE) &&
86             (!r->in.filter)) {
87                 return WERR_CM_INVALID_POINTER;
88         }
89
90         if (!(devicepath = get_device_path(p->mem_ctx, r->in.filter))) {
91                 return WERR_NOMEM;
92         }
93
94         size = strlen(devicepath) + 2;
95
96         if (*r->in.length < size) {
97                 return WERR_CM_BUFFER_SMALL;
98         }
99
100         multi_sz = talloc_zero_array(p->mem_ctx, const char *, 2);
101         if (!multi_sz) {
102                 return WERR_NOMEM;
103         }
104
105         multi_sz[0] = devicepath;
106
107         if (!push_reg_multi_sz(multi_sz, &blob, multi_sz)) {
108                 return WERR_NOMEM;
109         }
110
111         if (*r->in.length < blob.length/2) {
112                 return WERR_CM_BUFFER_SMALL;
113         }
114
115         memcpy(r->out.buffer, blob.data, blob.length);
116
117         return WERR_OK;
118 }
119
120 /********************************************************************
121 _PNP_GetDeviceRegProp
122 ********************************************************************/
123
124 WERROR _PNP_GetDeviceRegProp(pipes_struct *p,
125                              struct PNP_GetDeviceRegProp *r)
126 {
127         char *ptr;
128         struct regval_ctr *values;
129         struct regval_blob *val;
130
131         switch( r->in.property ) {
132         case DEV_REGPROP_DESC:
133
134                 /* just parse the service name from the device path and then
135                    lookup the display name */
136                 if ( !(ptr = strrchr_m( r->in.devicepath, '\\' )) )
137                         return WERR_GENERAL_FAILURE;
138                 *ptr = '\0';
139
140                 if ( !(ptr = strrchr_m( r->in.devicepath, '_' )) )
141                         return WERR_GENERAL_FAILURE;
142                 ptr++;
143
144                 if ( !(values = svcctl_fetch_regvalues(
145                                ptr, p->server_info->ptok)))
146                         return WERR_GENERAL_FAILURE;
147
148                 if ( !(val = regval_ctr_getvalue( values, "DisplayName" )) ) {
149                         TALLOC_FREE( values );
150                         return WERR_GENERAL_FAILURE;
151                 }
152
153                 if (*r->in.buffer_size < regval_size(val)) {
154                         *r->out.needed = regval_size(val);
155                         *r->out.buffer_size = 0;
156                         TALLOC_FREE( values );
157                         return WERR_CM_BUFFER_SMALL;
158                 }
159
160                 r->out.buffer = (uint8_t *)talloc_memdup(p->mem_ctx, regval_data_p(val), regval_size(val));
161                 TALLOC_FREE(values);
162                 if (!r->out.buffer) {
163                         return WERR_NOMEM;
164                 }
165
166                 *r->out.reg_data_type = REG_SZ; /* always 1...tested using a remove device manager connection */
167                 *r->out.buffer_size = regval_size(val);
168                 *r->out.needed = regval_size(val);
169
170                 break;
171
172         default:
173                 *r->out.reg_data_type = 0x00437c98; /* ??? */
174                 return WERR_CM_NO_SUCH_VALUE;
175         }
176
177         return WERR_OK;
178 }
179
180 /********************************************************************
181 ********************************************************************/
182
183 WERROR _PNP_ValidateDeviceInstance(pipes_struct *p,
184                                    struct PNP_ValidateDeviceInstance *r)
185 {
186         /* whatever dude */
187         return WERR_OK;
188 }
189
190 /********************************************************************
191 ********************************************************************/
192
193 WERROR _PNP_GetHwProfInfo(pipes_struct *p,
194                           struct PNP_GetHwProfInfo *r)
195 {
196         /* steal the incoming buffer */
197
198         r->out.info = r->in.info;
199
200         /* Take the 5th Ammentment */
201
202         return WERR_CM_NO_MORE_HW_PROFILES;
203 }
204
205 /********************************************************************
206 ********************************************************************/
207
208 WERROR _PNP_HwProfFlags(pipes_struct *p,
209                         struct PNP_HwProfFlags *r)
210 {
211         /* just nod your head */
212
213         return WERR_OK;
214 }
215
216 /****************************************************************
217 ****************************************************************/
218
219 WERROR _PNP_Disconnect(pipes_struct *p,
220                        struct PNP_Disconnect *r)
221 {
222         p->rng_fault_state = true;
223         return WERR_NOT_SUPPORTED;
224 }
225
226 /****************************************************************
227 ****************************************************************/
228
229 WERROR _PNP_Connect(pipes_struct *p,
230                     struct PNP_Connect *r)
231 {
232         p->rng_fault_state = true;
233         return WERR_NOT_SUPPORTED;
234 }
235
236 /****************************************************************
237 ****************************************************************/
238
239 WERROR _PNP_GetGlobalState(pipes_struct *p,
240                            struct PNP_GetGlobalState *r)
241 {
242         p->rng_fault_state = true;
243         return WERR_NOT_SUPPORTED;
244 }
245
246 /****************************************************************
247 ****************************************************************/
248
249 WERROR _PNP_InitDetection(pipes_struct *p,
250                           struct PNP_InitDetection *r)
251 {
252         p->rng_fault_state = true;
253         return WERR_NOT_SUPPORTED;
254 }
255
256 /****************************************************************
257 ****************************************************************/
258
259 WERROR _PNP_ReportLogOn(pipes_struct *p,
260                         struct PNP_ReportLogOn *r)
261 {
262         p->rng_fault_state = true;
263         return WERR_NOT_SUPPORTED;
264 }
265
266 /****************************************************************
267 ****************************************************************/
268
269 WERROR _PNP_GetRootDeviceInstance(pipes_struct *p,
270                                   struct PNP_GetRootDeviceInstance *r)
271 {
272         p->rng_fault_state = true;
273         return WERR_NOT_SUPPORTED;
274 }
275
276 /****************************************************************
277 ****************************************************************/
278
279 WERROR _PNP_GetRelatedDeviceInstance(pipes_struct *p,
280                                      struct PNP_GetRelatedDeviceInstance *r)
281 {
282         p->rng_fault_state = true;
283         return WERR_NOT_SUPPORTED;
284 }
285
286 /****************************************************************
287 ****************************************************************/
288
289 WERROR _PNP_EnumerateSubKeys(pipes_struct *p,
290                              struct PNP_EnumerateSubKeys *r)
291 {
292         p->rng_fault_state = true;
293         return WERR_NOT_SUPPORTED;
294 }
295
296 /****************************************************************
297 ****************************************************************/
298
299 WERROR _PNP_GetDepth(pipes_struct *p,
300                      struct PNP_GetDepth *r)
301 {
302         p->rng_fault_state = true;
303         return WERR_NOT_SUPPORTED;
304 }
305
306 /****************************************************************
307 ****************************************************************/
308
309 WERROR _PNP_SetDeviceRegProp(pipes_struct *p,
310                              struct PNP_SetDeviceRegProp *r)
311 {
312         p->rng_fault_state = true;
313         return WERR_NOT_SUPPORTED;
314 }
315
316 /****************************************************************
317 ****************************************************************/
318
319 WERROR _PNP_GetClassInstance(pipes_struct *p,
320                              struct PNP_GetClassInstance *r)
321 {
322         p->rng_fault_state = true;
323         return WERR_NOT_SUPPORTED;
324 }
325
326 /****************************************************************
327 ****************************************************************/
328
329 WERROR _PNP_CreateKey(pipes_struct *p,
330                       struct PNP_CreateKey *r)
331 {
332         p->rng_fault_state = true;
333         return WERR_NOT_SUPPORTED;
334 }
335
336 /****************************************************************
337 ****************************************************************/
338
339 WERROR _PNP_DeleteRegistryKey(pipes_struct *p,
340                               struct PNP_DeleteRegistryKey *r)
341 {
342         p->rng_fault_state = true;
343         return WERR_NOT_SUPPORTED;
344 }
345
346 /****************************************************************
347 ****************************************************************/
348
349 WERROR _PNP_GetClassCount(pipes_struct *p,
350                           struct PNP_GetClassCount *r)
351 {
352         p->rng_fault_state = true;
353         return WERR_NOT_SUPPORTED;
354 }
355
356 /****************************************************************
357 ****************************************************************/
358
359 WERROR _PNP_GetClassName(pipes_struct *p,
360                          struct PNP_GetClassName *r)
361 {
362         p->rng_fault_state = true;
363         return WERR_NOT_SUPPORTED;
364 }
365
366 /****************************************************************
367 ****************************************************************/
368
369 WERROR _PNP_DeleteClassKey(pipes_struct *p,
370                            struct PNP_DeleteClassKey *r)
371 {
372         p->rng_fault_state = true;
373         return WERR_NOT_SUPPORTED;
374 }
375
376 /****************************************************************
377 ****************************************************************/
378
379 WERROR _PNP_GetInterfaceDeviceAlias(pipes_struct *p,
380                                     struct PNP_GetInterfaceDeviceAlias *r)
381 {
382         p->rng_fault_state = true;
383         return WERR_NOT_SUPPORTED;
384 }
385
386 /****************************************************************
387 ****************************************************************/
388
389 WERROR _PNP_GetInterfaceDeviceList(pipes_struct *p,
390                                    struct PNP_GetInterfaceDeviceList *r)
391 {
392         p->rng_fault_state = true;
393         return WERR_NOT_SUPPORTED;
394 }
395
396 /****************************************************************
397 ****************************************************************/
398
399 WERROR _PNP_GetInterfaceDeviceListSize(pipes_struct *p,
400                                        struct PNP_GetInterfaceDeviceListSize *r)
401 {
402         p->rng_fault_state = true;
403         return WERR_NOT_SUPPORTED;
404 }
405
406 /****************************************************************
407 ****************************************************************/
408
409 WERROR _PNP_RegisterDeviceClassAssociation(pipes_struct *p,
410                                            struct PNP_RegisterDeviceClassAssociation *r)
411 {
412         p->rng_fault_state = true;
413         return WERR_NOT_SUPPORTED;
414 }
415
416 /****************************************************************
417 ****************************************************************/
418
419 WERROR _PNP_UnregisterDeviceClassAssociation(pipes_struct *p,
420                                              struct PNP_UnregisterDeviceClassAssociation *r)
421 {
422         p->rng_fault_state = true;
423         return WERR_NOT_SUPPORTED;
424 }
425
426 /****************************************************************
427 ****************************************************************/
428
429 WERROR _PNP_GetClassRegProp(pipes_struct *p,
430                             struct PNP_GetClassRegProp *r)
431 {
432         p->rng_fault_state = true;
433         return WERR_NOT_SUPPORTED;
434 }
435
436 /****************************************************************
437 ****************************************************************/
438
439 WERROR _PNP_SetClassRegProp(pipes_struct *p,
440                             struct PNP_SetClassRegProp *r)
441 {
442         p->rng_fault_state = true;
443         return WERR_NOT_SUPPORTED;
444 }
445
446 /****************************************************************
447 ****************************************************************/
448
449 WERROR _PNP_CreateDevInst(pipes_struct *p,
450                           struct PNP_CreateDevInst *r)
451 {
452         p->rng_fault_state = true;
453         return WERR_NOT_SUPPORTED;
454 }
455
456 /****************************************************************
457 ****************************************************************/
458
459 WERROR _PNP_DeviceInstanceAction(pipes_struct *p,
460                                  struct PNP_DeviceInstanceAction *r)
461 {
462         p->rng_fault_state = true;
463         return WERR_NOT_SUPPORTED;
464 }
465
466 /****************************************************************
467 ****************************************************************/
468
469 WERROR _PNP_GetDeviceStatus(pipes_struct *p,
470                             struct PNP_GetDeviceStatus *r)
471 {
472         p->rng_fault_state = true;
473         return WERR_NOT_SUPPORTED;
474 }
475
476 /****************************************************************
477 ****************************************************************/
478
479 WERROR _PNP_SetDeviceProblem(pipes_struct *p,
480                              struct PNP_SetDeviceProblem *r)
481 {
482         p->rng_fault_state = true;
483         return WERR_NOT_SUPPORTED;
484 }
485
486 /****************************************************************
487 ****************************************************************/
488
489 WERROR _PNP_DisableDevInst(pipes_struct *p,
490                            struct PNP_DisableDevInst *r)
491 {
492         p->rng_fault_state = true;
493         return WERR_NOT_SUPPORTED;
494 }
495
496 /****************************************************************
497 ****************************************************************/
498
499 WERROR _PNP_UninstallDevInst(pipes_struct *p,
500                              struct PNP_UninstallDevInst *r)
501 {
502         p->rng_fault_state = true;
503         return WERR_NOT_SUPPORTED;
504 }
505
506 /****************************************************************
507 ****************************************************************/
508
509 WERROR _PNP_AddID(pipes_struct *p,
510                   struct PNP_AddID *r)
511 {
512         p->rng_fault_state = true;
513         return WERR_NOT_SUPPORTED;
514 }
515
516 /****************************************************************
517 ****************************************************************/
518
519 WERROR _PNP_RegisterDriver(pipes_struct *p,
520                            struct PNP_RegisterDriver *r)
521 {
522         p->rng_fault_state = true;
523         return WERR_NOT_SUPPORTED;
524 }
525
526 /****************************************************************
527 ****************************************************************/
528
529 WERROR _PNP_QueryRemove(pipes_struct *p,
530                         struct PNP_QueryRemove *r)
531 {
532         p->rng_fault_state = true;
533         return WERR_NOT_SUPPORTED;
534 }
535
536 /****************************************************************
537 ****************************************************************/
538
539 WERROR _PNP_RequestDeviceEject(pipes_struct *p,
540                                struct PNP_RequestDeviceEject *r)
541 {
542         p->rng_fault_state = true;
543         return WERR_NOT_SUPPORTED;
544 }
545
546 /****************************************************************
547 ****************************************************************/
548
549 WERROR _PNP_IsDockStationPresent(pipes_struct *p,
550                                  struct PNP_IsDockStationPresent *r)
551 {
552         p->rng_fault_state = true;
553         return WERR_NOT_SUPPORTED;
554 }
555
556 /****************************************************************
557 ****************************************************************/
558
559 WERROR _PNP_RequestEjectPC(pipes_struct *p,
560                            struct PNP_RequestEjectPC *r)
561 {
562         p->rng_fault_state = true;
563         return WERR_NOT_SUPPORTED;
564 }
565
566 /****************************************************************
567 ****************************************************************/
568
569 WERROR _PNP_AddEmptyLogConf(pipes_struct *p,
570                             struct PNP_AddEmptyLogConf *r)
571 {
572         p->rng_fault_state = true;
573         return WERR_NOT_SUPPORTED;
574 }
575
576 /****************************************************************
577 ****************************************************************/
578
579 WERROR _PNP_FreeLogConf(pipes_struct *p,
580                         struct PNP_FreeLogConf *r)
581 {
582         p->rng_fault_state = true;
583         return WERR_NOT_SUPPORTED;
584 }
585
586 /****************************************************************
587 ****************************************************************/
588
589 WERROR _PNP_GetFirstLogConf(pipes_struct *p,
590                             struct PNP_GetFirstLogConf *r)
591 {
592         p->rng_fault_state = true;
593         return WERR_NOT_SUPPORTED;
594 }
595
596 /****************************************************************
597 ****************************************************************/
598
599 WERROR _PNP_GetNextLogConf(pipes_struct *p,
600                            struct PNP_GetNextLogConf *r)
601 {
602         p->rng_fault_state = true;
603         return WERR_NOT_SUPPORTED;
604 }
605
606 /****************************************************************
607 ****************************************************************/
608
609 WERROR _PNP_GetLogConfPriority(pipes_struct *p,
610                                struct PNP_GetLogConfPriority *r)
611 {
612         p->rng_fault_state = true;
613         return WERR_NOT_SUPPORTED;
614 }
615
616 /****************************************************************
617 ****************************************************************/
618
619 WERROR _PNP_AddResDes(pipes_struct *p,
620                       struct PNP_AddResDes *r)
621 {
622         p->rng_fault_state = true;
623         return WERR_NOT_SUPPORTED;
624 }
625
626 /****************************************************************
627 ****************************************************************/
628
629 WERROR _PNP_FreeResDes(pipes_struct *p,
630                        struct PNP_FreeResDes *r)
631 {
632         p->rng_fault_state = true;
633         return WERR_NOT_SUPPORTED;
634 }
635
636 /****************************************************************
637 ****************************************************************/
638
639 WERROR _PNP_GetNextResDes(pipes_struct *p,
640                           struct PNP_GetNextResDes *r)
641 {
642         p->rng_fault_state = true;
643         return WERR_NOT_SUPPORTED;
644 }
645
646 /****************************************************************
647 ****************************************************************/
648
649 WERROR _PNP_GetResDesData(pipes_struct *p,
650                           struct PNP_GetResDesData *r)
651 {
652         p->rng_fault_state = true;
653         return WERR_NOT_SUPPORTED;
654 }
655
656 /****************************************************************
657 ****************************************************************/
658
659 WERROR _PNP_GetResDesDataSize(pipes_struct *p,
660                               struct PNP_GetResDesDataSize *r)
661 {
662         p->rng_fault_state = true;
663         return WERR_NOT_SUPPORTED;
664 }
665
666 /****************************************************************
667 ****************************************************************/
668
669 WERROR _PNP_ModifyResDes(pipes_struct *p,
670                          struct PNP_ModifyResDes *r)
671 {
672         p->rng_fault_state = true;
673         return WERR_NOT_SUPPORTED;
674 }
675
676 /****************************************************************
677 ****************************************************************/
678
679 WERROR _PNP_DetectResourceLimit(pipes_struct *p,
680                                 struct PNP_DetectResourceLimit *r)
681 {
682         p->rng_fault_state = true;
683         return WERR_NOT_SUPPORTED;
684 }
685
686 /****************************************************************
687 ****************************************************************/
688
689 WERROR _PNP_QueryResConfList(pipes_struct *p,
690                              struct PNP_QueryResConfList *r)
691 {
692         p->rng_fault_state = true;
693         return WERR_NOT_SUPPORTED;
694 }
695
696 /****************************************************************
697 ****************************************************************/
698
699 WERROR _PNP_SetHwProf(pipes_struct *p,
700                       struct PNP_SetHwProf *r)
701 {
702         p->rng_fault_state = true;
703         return WERR_NOT_SUPPORTED;
704 }
705
706 /****************************************************************
707 ****************************************************************/
708
709 WERROR _PNP_QueryArbitratorFreeData(pipes_struct *p,
710                                     struct PNP_QueryArbitratorFreeData *r)
711 {
712         p->rng_fault_state = true;
713         return WERR_NOT_SUPPORTED;
714 }
715
716 /****************************************************************
717 ****************************************************************/
718
719 WERROR _PNP_QueryArbitratorFreeSize(pipes_struct *p,
720                                     struct PNP_QueryArbitratorFreeSize *r)
721 {
722         p->rng_fault_state = true;
723         return WERR_NOT_SUPPORTED;
724 }
725
726 /****************************************************************
727 ****************************************************************/
728
729 WERROR _PNP_RunDetection(pipes_struct *p,
730                          struct PNP_RunDetection *r)
731 {
732         p->rng_fault_state = true;
733         return WERR_NOT_SUPPORTED;
734 }
735
736 /****************************************************************
737 ****************************************************************/
738
739 WERROR _PNP_RegisterNotification(pipes_struct *p,
740                                  struct PNP_RegisterNotification *r)
741 {
742         p->rng_fault_state = true;
743         return WERR_NOT_SUPPORTED;
744 }
745
746 /****************************************************************
747 ****************************************************************/
748
749 WERROR _PNP_UnregisterNotification(pipes_struct *p,
750                                    struct PNP_UnregisterNotification *r)
751 {
752         p->rng_fault_state = true;
753         return WERR_NOT_SUPPORTED;
754 }
755
756 /****************************************************************
757 ****************************************************************/
758
759 WERROR _PNP_GetCustomDevProp(pipes_struct *p,
760                              struct PNP_GetCustomDevProp *r)
761 {
762         p->rng_fault_state = true;
763         return WERR_NOT_SUPPORTED;
764 }
765
766 /****************************************************************
767 ****************************************************************/
768
769 WERROR _PNP_GetVersionInternal(pipes_struct *p,
770                                struct PNP_GetVersionInternal *r)
771 {
772         p->rng_fault_state = true;
773         return WERR_NOT_SUPPORTED;
774 }
775
776 /****************************************************************
777 ****************************************************************/
778
779 WERROR _PNP_GetBlockedDriverInfo(pipes_struct *p,
780                                  struct PNP_GetBlockedDriverInfo *r)
781 {
782         p->rng_fault_state = true;
783         return WERR_NOT_SUPPORTED;
784 }
785
786 /****************************************************************
787 ****************************************************************/
788
789 WERROR _PNP_GetServerSideDeviceInstallFlags(pipes_struct *p,
790                                             struct PNP_GetServerSideDeviceInstallFlags *r)
791 {
792         p->rng_fault_state = true;
793         return WERR_NOT_SUPPORTED;
794 }
795