source: branches/samba-3.2.x/source/rpc_server/srv_ntsvcs_nt.c@ 198

Last change on this file since 198 was 136, checked in by Paul Smedley, 18 years ago

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