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