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