57f642a0fe451daaebdf4aa2d37d86c205579f25
[kai/samba.git] / source3 / rpc_server / ntsvcs / 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 "services/svc_winreg_glue.h"
25 #include "../libcli/registry/util_reg.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(struct 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(struct 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(struct 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(struct pipes_struct *p,
125                              struct PNP_GetDeviceRegProp *r)
126 {
127         char *ptr;
128         const char *result;
129         DATA_BLOB blob;
130         TALLOC_CTX *mem_ctx = NULL;
131
132         switch( r->in.property ) {
133         case DEV_REGPROP_DESC:
134
135                 /* just parse the service name from the device path and then
136                    lookup the display name */
137                 if ( !(ptr = strrchr_m( r->in.devicepath, '\\' )) )
138                         return WERR_GENERAL_FAILURE;
139                 *ptr = '\0';
140
141                 if ( !(ptr = strrchr_m( r->in.devicepath, '_' )) )
142                         return WERR_GENERAL_FAILURE;
143                 ptr++;
144
145                 mem_ctx = talloc_stackframe();
146
147                 result = svcctl_lookup_dispname(mem_ctx,
148                                                 p->msg_ctx,
149                                                 p->session_info,
150                                                 ptr);
151                 if (result == NULL) {
152                         return WERR_GENERAL_FAILURE;
153                 }
154
155                 if (!push_reg_sz(mem_ctx, &blob, result)) {
156                         talloc_free(mem_ctx);
157                         return WERR_GENERAL_FAILURE;
158                 }
159
160                 if (*r->in.buffer_size < blob.length) {
161                         *r->out.needed = blob.length;
162                         *r->out.buffer_size = 0;
163                         talloc_free(mem_ctx);
164                         return WERR_CM_BUFFER_SMALL;
165                 }
166
167                 r->out.buffer = (uint8_t *)talloc_memdup(p->mem_ctx, blob.data, blob.length);
168                 talloc_free(mem_ctx);
169                 if (!r->out.buffer) {
170                         return WERR_NOMEM;
171                 }
172
173                 *r->out.reg_data_type = REG_SZ; /* always 1...tested using a remove device manager connection */
174                 *r->out.buffer_size = blob.length;
175                 *r->out.needed = blob.length;
176
177                 break;
178
179         default:
180                 *r->out.reg_data_type = 0x00437c98; /* ??? */
181                 return WERR_CM_NO_SUCH_VALUE;
182         }
183
184         return WERR_OK;
185 }
186
187 /********************************************************************
188 ********************************************************************/
189
190 WERROR _PNP_ValidateDeviceInstance(struct pipes_struct *p,
191                                    struct PNP_ValidateDeviceInstance *r)
192 {
193         /* whatever dude */
194         return WERR_OK;
195 }
196
197 /********************************************************************
198 ********************************************************************/
199
200 WERROR _PNP_GetHwProfInfo(struct pipes_struct *p,
201                           struct PNP_GetHwProfInfo *r)
202 {
203         /* steal the incoming buffer */
204
205         r->out.info = r->in.info;
206
207         /* Take the 5th Ammentment */
208
209         return WERR_CM_NO_MORE_HW_PROFILES;
210 }
211
212 /********************************************************************
213 ********************************************************************/
214
215 WERROR _PNP_HwProfFlags(struct pipes_struct *p,
216                         struct PNP_HwProfFlags *r)
217 {
218         /* just nod your head */
219
220         return WERR_OK;
221 }
222
223 /****************************************************************
224 ****************************************************************/
225
226 WERROR _PNP_Disconnect(struct pipes_struct *p,
227                        struct PNP_Disconnect *r)
228 {
229         p->rng_fault_state = true;
230         return WERR_NOT_SUPPORTED;
231 }
232
233 /****************************************************************
234 ****************************************************************/
235
236 WERROR _PNP_Connect(struct pipes_struct *p,
237                     struct PNP_Connect *r)
238 {
239         p->rng_fault_state = true;
240         return WERR_NOT_SUPPORTED;
241 }
242
243 /****************************************************************
244 ****************************************************************/
245
246 WERROR _PNP_GetGlobalState(struct pipes_struct *p,
247                            struct PNP_GetGlobalState *r)
248 {
249         p->rng_fault_state = true;
250         return WERR_NOT_SUPPORTED;
251 }
252
253 /****************************************************************
254 ****************************************************************/
255
256 WERROR _PNP_InitDetection(struct pipes_struct *p,
257                           struct PNP_InitDetection *r)
258 {
259         p->rng_fault_state = true;
260         return WERR_NOT_SUPPORTED;
261 }
262
263 /****************************************************************
264 ****************************************************************/
265
266 WERROR _PNP_ReportLogOn(struct pipes_struct *p,
267                         struct PNP_ReportLogOn *r)
268 {
269         p->rng_fault_state = true;
270         return WERR_NOT_SUPPORTED;
271 }
272
273 /****************************************************************
274 ****************************************************************/
275
276 WERROR _PNP_GetRootDeviceInstance(struct pipes_struct *p,
277                                   struct PNP_GetRootDeviceInstance *r)
278 {
279         p->rng_fault_state = true;
280         return WERR_NOT_SUPPORTED;
281 }
282
283 /****************************************************************
284 ****************************************************************/
285
286 WERROR _PNP_GetRelatedDeviceInstance(struct pipes_struct *p,
287                                      struct PNP_GetRelatedDeviceInstance *r)
288 {
289         p->rng_fault_state = true;
290         return WERR_NOT_SUPPORTED;
291 }
292
293 /****************************************************************
294 ****************************************************************/
295
296 WERROR _PNP_EnumerateSubKeys(struct pipes_struct *p,
297                              struct PNP_EnumerateSubKeys *r)
298 {
299         p->rng_fault_state = true;
300         return WERR_NOT_SUPPORTED;
301 }
302
303 /****************************************************************
304 ****************************************************************/
305
306 WERROR _PNP_GetDepth(struct pipes_struct *p,
307                      struct PNP_GetDepth *r)
308 {
309         p->rng_fault_state = true;
310         return WERR_NOT_SUPPORTED;
311 }
312
313 /****************************************************************
314 ****************************************************************/
315
316 WERROR _PNP_SetDeviceRegProp(struct pipes_struct *p,
317                              struct PNP_SetDeviceRegProp *r)
318 {
319         p->rng_fault_state = true;
320         return WERR_NOT_SUPPORTED;
321 }
322
323 /****************************************************************
324 ****************************************************************/
325
326 WERROR _PNP_GetClassInstance(struct pipes_struct *p,
327                              struct PNP_GetClassInstance *r)
328 {
329         p->rng_fault_state = true;
330         return WERR_NOT_SUPPORTED;
331 }
332
333 /****************************************************************
334 ****************************************************************/
335
336 WERROR _PNP_CreateKey(struct pipes_struct *p,
337                       struct PNP_CreateKey *r)
338 {
339         p->rng_fault_state = true;
340         return WERR_NOT_SUPPORTED;
341 }
342
343 /****************************************************************
344 ****************************************************************/
345
346 WERROR _PNP_DeleteRegistryKey(struct pipes_struct *p,
347                               struct PNP_DeleteRegistryKey *r)
348 {
349         p->rng_fault_state = true;
350         return WERR_NOT_SUPPORTED;
351 }
352
353 /****************************************************************
354 ****************************************************************/
355
356 WERROR _PNP_GetClassCount(struct pipes_struct *p,
357                           struct PNP_GetClassCount *r)
358 {
359         p->rng_fault_state = true;
360         return WERR_NOT_SUPPORTED;
361 }
362
363 /****************************************************************
364 ****************************************************************/
365
366 WERROR _PNP_GetClassName(struct pipes_struct *p,
367                          struct PNP_GetClassName *r)
368 {
369         p->rng_fault_state = true;
370         return WERR_NOT_SUPPORTED;
371 }
372
373 /****************************************************************
374 ****************************************************************/
375
376 WERROR _PNP_DeleteClassKey(struct pipes_struct *p,
377                            struct PNP_DeleteClassKey *r)
378 {
379         p->rng_fault_state = true;
380         return WERR_NOT_SUPPORTED;
381 }
382
383 /****************************************************************
384 ****************************************************************/
385
386 WERROR _PNP_GetInterfaceDeviceAlias(struct pipes_struct *p,
387                                     struct PNP_GetInterfaceDeviceAlias *r)
388 {
389         p->rng_fault_state = true;
390         return WERR_NOT_SUPPORTED;
391 }
392
393 /****************************************************************
394 ****************************************************************/
395
396 WERROR _PNP_GetInterfaceDeviceList(struct pipes_struct *p,
397                                    struct PNP_GetInterfaceDeviceList *r)
398 {
399         p->rng_fault_state = true;
400         return WERR_NOT_SUPPORTED;
401 }
402
403 /****************************************************************
404 ****************************************************************/
405
406 WERROR _PNP_GetInterfaceDeviceListSize(struct pipes_struct *p,
407                                        struct PNP_GetInterfaceDeviceListSize *r)
408 {
409         p->rng_fault_state = true;
410         return WERR_NOT_SUPPORTED;
411 }
412
413 /****************************************************************
414 ****************************************************************/
415
416 WERROR _PNP_RegisterDeviceClassAssociation(struct pipes_struct *p,
417                                            struct PNP_RegisterDeviceClassAssociation *r)
418 {
419         p->rng_fault_state = true;
420         return WERR_NOT_SUPPORTED;
421 }
422
423 /****************************************************************
424 ****************************************************************/
425
426 WERROR _PNP_UnregisterDeviceClassAssociation(struct pipes_struct *p,
427                                              struct PNP_UnregisterDeviceClassAssociation *r)
428 {
429         p->rng_fault_state = true;
430         return WERR_NOT_SUPPORTED;
431 }
432
433 /****************************************************************
434 ****************************************************************/
435
436 WERROR _PNP_GetClassRegProp(struct pipes_struct *p,
437                             struct PNP_GetClassRegProp *r)
438 {
439         p->rng_fault_state = true;
440         return WERR_NOT_SUPPORTED;
441 }
442
443 /****************************************************************
444 ****************************************************************/
445
446 WERROR _PNP_SetClassRegProp(struct pipes_struct *p,
447                             struct PNP_SetClassRegProp *r)
448 {
449         p->rng_fault_state = true;
450         return WERR_NOT_SUPPORTED;
451 }
452
453 /****************************************************************
454 ****************************************************************/
455
456 WERROR _PNP_CreateDevInst(struct pipes_struct *p,
457                           struct PNP_CreateDevInst *r)
458 {
459         p->rng_fault_state = true;
460         return WERR_NOT_SUPPORTED;
461 }
462
463 /****************************************************************
464 ****************************************************************/
465
466 WERROR _PNP_DeviceInstanceAction(struct pipes_struct *p,
467                                  struct PNP_DeviceInstanceAction *r)
468 {
469         p->rng_fault_state = true;
470         return WERR_NOT_SUPPORTED;
471 }
472
473 /****************************************************************
474 ****************************************************************/
475
476 WERROR _PNP_GetDeviceStatus(struct pipes_struct *p,
477                             struct PNP_GetDeviceStatus *r)
478 {
479         p->rng_fault_state = true;
480         return WERR_NOT_SUPPORTED;
481 }
482
483 /****************************************************************
484 ****************************************************************/
485
486 WERROR _PNP_SetDeviceProblem(struct pipes_struct *p,
487                              struct PNP_SetDeviceProblem *r)
488 {
489         p->rng_fault_state = true;
490         return WERR_NOT_SUPPORTED;
491 }
492
493 /****************************************************************
494 ****************************************************************/
495
496 WERROR _PNP_DisableDevInst(struct pipes_struct *p,
497                            struct PNP_DisableDevInst *r)
498 {
499         p->rng_fault_state = true;
500         return WERR_NOT_SUPPORTED;
501 }
502
503 /****************************************************************
504 ****************************************************************/
505
506 WERROR _PNP_UninstallDevInst(struct pipes_struct *p,
507                              struct PNP_UninstallDevInst *r)
508 {
509         p->rng_fault_state = true;
510         return WERR_NOT_SUPPORTED;
511 }
512
513 /****************************************************************
514 ****************************************************************/
515
516 WERROR _PNP_AddID(struct pipes_struct *p,
517                   struct PNP_AddID *r)
518 {
519         p->rng_fault_state = true;
520         return WERR_NOT_SUPPORTED;
521 }
522
523 /****************************************************************
524 ****************************************************************/
525
526 WERROR _PNP_RegisterDriver(struct pipes_struct *p,
527                            struct PNP_RegisterDriver *r)
528 {
529         p->rng_fault_state = true;
530         return WERR_NOT_SUPPORTED;
531 }
532
533 /****************************************************************
534 ****************************************************************/
535
536 WERROR _PNP_QueryRemove(struct pipes_struct *p,
537                         struct PNP_QueryRemove *r)
538 {
539         p->rng_fault_state = true;
540         return WERR_NOT_SUPPORTED;
541 }
542
543 /****************************************************************
544 ****************************************************************/
545
546 WERROR _PNP_RequestDeviceEject(struct pipes_struct *p,
547                                struct PNP_RequestDeviceEject *r)
548 {
549         p->rng_fault_state = true;
550         return WERR_NOT_SUPPORTED;
551 }
552
553 /****************************************************************
554 ****************************************************************/
555
556 WERROR _PNP_IsDockStationPresent(struct pipes_struct *p,
557                                  struct PNP_IsDockStationPresent *r)
558 {
559         p->rng_fault_state = true;
560         return WERR_NOT_SUPPORTED;
561 }
562
563 /****************************************************************
564 ****************************************************************/
565
566 WERROR _PNP_RequestEjectPC(struct pipes_struct *p,
567                            struct PNP_RequestEjectPC *r)
568 {
569         p->rng_fault_state = true;
570         return WERR_NOT_SUPPORTED;
571 }
572
573 /****************************************************************
574 ****************************************************************/
575
576 WERROR _PNP_AddEmptyLogConf(struct pipes_struct *p,
577                             struct PNP_AddEmptyLogConf *r)
578 {
579         p->rng_fault_state = true;
580         return WERR_NOT_SUPPORTED;
581 }
582
583 /****************************************************************
584 ****************************************************************/
585
586 WERROR _PNP_FreeLogConf(struct pipes_struct *p,
587                         struct PNP_FreeLogConf *r)
588 {
589         p->rng_fault_state = true;
590         return WERR_NOT_SUPPORTED;
591 }
592
593 /****************************************************************
594 ****************************************************************/
595
596 WERROR _PNP_GetFirstLogConf(struct pipes_struct *p,
597                             struct PNP_GetFirstLogConf *r)
598 {
599         p->rng_fault_state = true;
600         return WERR_NOT_SUPPORTED;
601 }
602
603 /****************************************************************
604 ****************************************************************/
605
606 WERROR _PNP_GetNextLogConf(struct pipes_struct *p,
607                            struct PNP_GetNextLogConf *r)
608 {
609         p->rng_fault_state = true;
610         return WERR_NOT_SUPPORTED;
611 }
612
613 /****************************************************************
614 ****************************************************************/
615
616 WERROR _PNP_GetLogConfPriority(struct pipes_struct *p,
617                                struct PNP_GetLogConfPriority *r)
618 {
619         p->rng_fault_state = true;
620         return WERR_NOT_SUPPORTED;
621 }
622
623 /****************************************************************
624 ****************************************************************/
625
626 WERROR _PNP_AddResDes(struct pipes_struct *p,
627                       struct PNP_AddResDes *r)
628 {
629         p->rng_fault_state = true;
630         return WERR_NOT_SUPPORTED;
631 }
632
633 /****************************************************************
634 ****************************************************************/
635
636 WERROR _PNP_FreeResDes(struct pipes_struct *p,
637                        struct PNP_FreeResDes *r)
638 {
639         p->rng_fault_state = true;
640         return WERR_NOT_SUPPORTED;
641 }
642
643 /****************************************************************
644 ****************************************************************/
645
646 WERROR _PNP_GetNextResDes(struct pipes_struct *p,
647                           struct PNP_GetNextResDes *r)
648 {
649         p->rng_fault_state = true;
650         return WERR_NOT_SUPPORTED;
651 }
652
653 /****************************************************************
654 ****************************************************************/
655
656 WERROR _PNP_GetResDesData(struct pipes_struct *p,
657                           struct PNP_GetResDesData *r)
658 {
659         p->rng_fault_state = true;
660         return WERR_NOT_SUPPORTED;
661 }
662
663 /****************************************************************
664 ****************************************************************/
665
666 WERROR _PNP_GetResDesDataSize(struct pipes_struct *p,
667                               struct PNP_GetResDesDataSize *r)
668 {
669         p->rng_fault_state = true;
670         return WERR_NOT_SUPPORTED;
671 }
672
673 /****************************************************************
674 ****************************************************************/
675
676 WERROR _PNP_ModifyResDes(struct pipes_struct *p,
677                          struct PNP_ModifyResDes *r)
678 {
679         p->rng_fault_state = true;
680         return WERR_NOT_SUPPORTED;
681 }
682
683 /****************************************************************
684 ****************************************************************/
685
686 WERROR _PNP_DetectResourceLimit(struct pipes_struct *p,
687                                 struct PNP_DetectResourceLimit *r)
688 {
689         p->rng_fault_state = true;
690         return WERR_NOT_SUPPORTED;
691 }
692
693 /****************************************************************
694 ****************************************************************/
695
696 WERROR _PNP_QueryResConfList(struct pipes_struct *p,
697                              struct PNP_QueryResConfList *r)
698 {
699         p->rng_fault_state = true;
700         return WERR_NOT_SUPPORTED;
701 }
702
703 /****************************************************************
704 ****************************************************************/
705
706 WERROR _PNP_SetHwProf(struct pipes_struct *p,
707                       struct PNP_SetHwProf *r)
708 {
709         p->rng_fault_state = true;
710         return WERR_NOT_SUPPORTED;
711 }
712
713 /****************************************************************
714 ****************************************************************/
715
716 WERROR _PNP_QueryArbitratorFreeData(struct pipes_struct *p,
717                                     struct PNP_QueryArbitratorFreeData *r)
718 {
719         p->rng_fault_state = true;
720         return WERR_NOT_SUPPORTED;
721 }
722
723 /****************************************************************
724 ****************************************************************/
725
726 WERROR _PNP_QueryArbitratorFreeSize(struct pipes_struct *p,
727                                     struct PNP_QueryArbitratorFreeSize *r)
728 {
729         p->rng_fault_state = true;
730         return WERR_NOT_SUPPORTED;
731 }
732
733 /****************************************************************
734 ****************************************************************/
735
736 WERROR _PNP_RunDetection(struct pipes_struct *p,
737                          struct PNP_RunDetection *r)
738 {
739         p->rng_fault_state = true;
740         return WERR_NOT_SUPPORTED;
741 }
742
743 /****************************************************************
744 ****************************************************************/
745
746 WERROR _PNP_RegisterNotification(struct pipes_struct *p,
747                                  struct PNP_RegisterNotification *r)
748 {
749         p->rng_fault_state = true;
750         return WERR_NOT_SUPPORTED;
751 }
752
753 /****************************************************************
754 ****************************************************************/
755
756 WERROR _PNP_UnregisterNotification(struct pipes_struct *p,
757                                    struct PNP_UnregisterNotification *r)
758 {
759         p->rng_fault_state = true;
760         return WERR_NOT_SUPPORTED;
761 }
762
763 /****************************************************************
764 ****************************************************************/
765
766 WERROR _PNP_GetCustomDevProp(struct pipes_struct *p,
767                              struct PNP_GetCustomDevProp *r)
768 {
769         p->rng_fault_state = true;
770         return WERR_NOT_SUPPORTED;
771 }
772
773 /****************************************************************
774 ****************************************************************/
775
776 WERROR _PNP_GetVersionInternal(struct pipes_struct *p,
777                                struct PNP_GetVersionInternal *r)
778 {
779         p->rng_fault_state = true;
780         return WERR_NOT_SUPPORTED;
781 }
782
783 /****************************************************************
784 ****************************************************************/
785
786 WERROR _PNP_GetBlockedDriverInfo(struct pipes_struct *p,
787                                  struct PNP_GetBlockedDriverInfo *r)
788 {
789         p->rng_fault_state = true;
790         return WERR_NOT_SUPPORTED;
791 }
792
793 /****************************************************************
794 ****************************************************************/
795
796 WERROR _PNP_GetServerSideDeviceInstallFlags(struct pipes_struct *p,
797                                             struct PNP_GetServerSideDeviceInstallFlags *r)
798 {
799         p->rng_fault_state = true;
800         return WERR_NOT_SUPPORTED;
801 }