source: vendor/current/source3/librpc/gen_ndr/ndr_echo_s.c@ 740

Last change on this file since 740 was 740, checked in by Silvan Scherrer, 12 years ago

Samba Server: update vendor to 3.6.0
File size: 13.5 KB
Line 
1/* server functions auto-generated by pidl */
2#include "librpc/gen_ndr/ndr_echo.h"
3
4/* rpcecho - dcerpc server boilerplate generated by pidl */
5
6
7static NTSTATUS rpcecho__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
8{
9#ifdef DCESRV_INTERFACE_RPCECHO_BIND
10 return DCESRV_INTERFACE_RPCECHO_BIND(dce_call,iface);
11#else
12 return NT_STATUS_OK;
13#endif
14}
15
16static void rpcecho__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
17{
18#ifdef DCESRV_INTERFACE_RPCECHO_UNBIND
19 DCESRV_INTERFACE_RPCECHO_UNBIND(context, iface);
20#else
21 return;
22#endif
23}
24
25static NTSTATUS rpcecho__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
26{
27 enum ndr_err_code ndr_err;
28 uint16_t opnum = dce_call->pkt.u.request.opnum;
29
30 dce_call->fault_code = 0;
31
32 if (opnum >= ndr_table_rpcecho.num_calls) {
33 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
34 return NT_STATUS_NET_WRITE_FAULT;
35 }
36
37 *r = talloc_named(mem_ctx,
38 ndr_table_rpcecho.calls[opnum].struct_size,
39 "struct %s",
40 ndr_table_rpcecho.calls[opnum].name);
41 NT_STATUS_HAVE_NO_MEMORY(*r);
42
43 /* unravel the NDR for the packet */
44 ndr_err = ndr_table_rpcecho.calls[opnum].ndr_pull(pull, NDR_IN, *r);
45 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
46 dcerpc_log_packet(dce_call->conn->packet_log_dir,
47 &ndr_table_rpcecho, opnum, NDR_IN,
48 &dce_call->pkt.u.request.stub_and_verifier);
49 dce_call->fault_code = DCERPC_FAULT_NDR;
50 return NT_STATUS_NET_WRITE_FAULT;
51 }
52
53 return NT_STATUS_OK;
54}
55
56static NTSTATUS rpcecho__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
57{
58 uint16_t opnum = dce_call->pkt.u.request.opnum;
59
60 switch (opnum) {
61 case 0: {
62 struct echo_AddOne *r2 = (struct echo_AddOne *)r;
63 if (DEBUGLEVEL >= 10) {
64 NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_IN, r2);
65 }
66 dcesrv_echo_AddOne(dce_call, mem_ctx, r2);
67 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
68 DEBUG(5,("function echo_AddOne will reply async\n"));
69 }
70 break;
71 }
72 case 1: {
73 struct echo_EchoData *r2 = (struct echo_EchoData *)r;
74 if (DEBUGLEVEL >= 10) {
75 NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_IN, r2);
76 }
77 dcesrv_echo_EchoData(dce_call, mem_ctx, r2);
78 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
79 DEBUG(5,("function echo_EchoData will reply async\n"));
80 }
81 break;
82 }
83 case 2: {
84 struct echo_SinkData *r2 = (struct echo_SinkData *)r;
85 if (DEBUGLEVEL >= 10) {
86 NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_IN, r2);
87 }
88 dcesrv_echo_SinkData(dce_call, mem_ctx, r2);
89 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
90 DEBUG(5,("function echo_SinkData will reply async\n"));
91 }
92 break;
93 }
94 case 3: {
95 struct echo_SourceData *r2 = (struct echo_SourceData *)r;
96 if (DEBUGLEVEL >= 10) {
97 NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_IN, r2);
98 }
99 dcesrv_echo_SourceData(dce_call, mem_ctx, r2);
100 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
101 DEBUG(5,("function echo_SourceData will reply async\n"));
102 }
103 break;
104 }
105 case 4: {
106 struct echo_TestCall *r2 = (struct echo_TestCall *)r;
107 if (DEBUGLEVEL >= 10) {
108 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_IN, r2);
109 }
110 dcesrv_echo_TestCall(dce_call, mem_ctx, r2);
111 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
112 DEBUG(5,("function echo_TestCall will reply async\n"));
113 }
114 break;
115 }
116 case 5: {
117 struct echo_TestCall2 *r2 = (struct echo_TestCall2 *)r;
118 if (DEBUGLEVEL >= 10) {
119 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_IN, r2);
120 }
121 r2->out.result = dcesrv_echo_TestCall2(dce_call, mem_ctx, r2);
122 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
123 DEBUG(5,("function echo_TestCall2 will reply async\n"));
124 }
125 break;
126 }
127 case 6: {
128 struct echo_TestSleep *r2 = (struct echo_TestSleep *)r;
129 if (DEBUGLEVEL >= 10) {
130 NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_IN, r2);
131 }
132 r2->out.result = dcesrv_echo_TestSleep(dce_call, mem_ctx, r2);
133 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
134 DEBUG(5,("function echo_TestSleep will reply async\n"));
135 }
136 break;
137 }
138 case 7: {
139 struct echo_TestEnum *r2 = (struct echo_TestEnum *)r;
140 if (DEBUGLEVEL >= 10) {
141 NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_IN, r2);
142 }
143 dcesrv_echo_TestEnum(dce_call, mem_ctx, r2);
144 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
145 DEBUG(5,("function echo_TestEnum will reply async\n"));
146 }
147 break;
148 }
149 case 8: {
150 struct echo_TestSurrounding *r2 = (struct echo_TestSurrounding *)r;
151 if (DEBUGLEVEL >= 10) {
152 NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_IN, r2);
153 }
154 dcesrv_echo_TestSurrounding(dce_call, mem_ctx, r2);
155 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
156 DEBUG(5,("function echo_TestSurrounding will reply async\n"));
157 }
158 break;
159 }
160 case 9: {
161 struct echo_TestDoublePointer *r2 = (struct echo_TestDoublePointer *)r;
162 if (DEBUGLEVEL >= 10) {
163 NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_IN, r2);
164 }
165 r2->out.result = dcesrv_echo_TestDoublePointer(dce_call, mem_ctx, r2);
166 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
167 DEBUG(5,("function echo_TestDoublePointer will reply async\n"));
168 }
169 break;
170 }
171
172 default:
173 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
174 break;
175 }
176
177 if (dce_call->fault_code != 0) {
178 dcerpc_log_packet(dce_call->conn->packet_log_dir,
179 &ndr_table_rpcecho, opnum, NDR_IN,
180 &dce_call->pkt.u.request.stub_and_verifier);
181 return NT_STATUS_NET_WRITE_FAULT;
182 }
183
184 return NT_STATUS_OK;
185}
186
187static NTSTATUS rpcecho__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
188{
189 uint16_t opnum = dce_call->pkt.u.request.opnum;
190
191 switch (opnum) {
192 case 0: {
193 struct echo_AddOne *r2 = (struct echo_AddOne *)r;
194 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
195 DEBUG(5,("function echo_AddOne replied async\n"));
196 }
197 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
198 NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_OUT | NDR_SET_VALUES, r2);
199 }
200 if (dce_call->fault_code != 0) {
201 DEBUG(2,("dcerpc_fault %s in echo_AddOne\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
202 }
203 break;
204 }
205 case 1: {
206 struct echo_EchoData *r2 = (struct echo_EchoData *)r;
207 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
208 DEBUG(5,("function echo_EchoData replied async\n"));
209 }
210 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
211 NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_OUT | NDR_SET_VALUES, r2);
212 }
213 if (dce_call->fault_code != 0) {
214 DEBUG(2,("dcerpc_fault %s in echo_EchoData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
215 }
216 break;
217 }
218 case 2: {
219 struct echo_SinkData *r2 = (struct echo_SinkData *)r;
220 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
221 DEBUG(5,("function echo_SinkData replied async\n"));
222 }
223 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
224 NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_OUT | NDR_SET_VALUES, r2);
225 }
226 if (dce_call->fault_code != 0) {
227 DEBUG(2,("dcerpc_fault %s in echo_SinkData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
228 }
229 break;
230 }
231 case 3: {
232 struct echo_SourceData *r2 = (struct echo_SourceData *)r;
233 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
234 DEBUG(5,("function echo_SourceData replied async\n"));
235 }
236 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
237 NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_OUT | NDR_SET_VALUES, r2);
238 }
239 if (dce_call->fault_code != 0) {
240 DEBUG(2,("dcerpc_fault %s in echo_SourceData\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
241 }
242 break;
243 }
244 case 4: {
245 struct echo_TestCall *r2 = (struct echo_TestCall *)r;
246 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
247 DEBUG(5,("function echo_TestCall replied async\n"));
248 }
249 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
250 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_OUT | NDR_SET_VALUES, r2);
251 }
252 if (dce_call->fault_code != 0) {
253 DEBUG(2,("dcerpc_fault %s in echo_TestCall\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
254 }
255 break;
256 }
257 case 5: {
258 struct echo_TestCall2 *r2 = (struct echo_TestCall2 *)r;
259 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
260 DEBUG(5,("function echo_TestCall2 replied async\n"));
261 }
262 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
263 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_OUT | NDR_SET_VALUES, r2);
264 }
265 if (dce_call->fault_code != 0) {
266 DEBUG(2,("dcerpc_fault %s in echo_TestCall2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
267 }
268 break;
269 }
270 case 6: {
271 struct echo_TestSleep *r2 = (struct echo_TestSleep *)r;
272 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
273 DEBUG(5,("function echo_TestSleep replied async\n"));
274 }
275 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
276 NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_OUT | NDR_SET_VALUES, r2);
277 }
278 if (dce_call->fault_code != 0) {
279 DEBUG(2,("dcerpc_fault %s in echo_TestSleep\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
280 }
281 break;
282 }
283 case 7: {
284 struct echo_TestEnum *r2 = (struct echo_TestEnum *)r;
285 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
286 DEBUG(5,("function echo_TestEnum replied async\n"));
287 }
288 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
289 NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_OUT | NDR_SET_VALUES, r2);
290 }
291 if (dce_call->fault_code != 0) {
292 DEBUG(2,("dcerpc_fault %s in echo_TestEnum\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
293 }
294 break;
295 }
296 case 8: {
297 struct echo_TestSurrounding *r2 = (struct echo_TestSurrounding *)r;
298 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
299 DEBUG(5,("function echo_TestSurrounding replied async\n"));
300 }
301 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
302 NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_OUT | NDR_SET_VALUES, r2);
303 }
304 if (dce_call->fault_code != 0) {
305 DEBUG(2,("dcerpc_fault %s in echo_TestSurrounding\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
306 }
307 break;
308 }
309 case 9: {
310 struct echo_TestDoublePointer *r2 = (struct echo_TestDoublePointer *)r;
311 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
312 DEBUG(5,("function echo_TestDoublePointer replied async\n"));
313 }
314 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
315 NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_OUT | NDR_SET_VALUES, r2);
316 }
317 if (dce_call->fault_code != 0) {
318 DEBUG(2,("dcerpc_fault %s in echo_TestDoublePointer\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
319 }
320 break;
321 }
322
323 default:
324 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
325 break;
326 }
327
328 if (dce_call->fault_code != 0) {
329 dcerpc_log_packet(dce_call->conn->packet_log_dir,
330 &ndr_table_rpcecho, opnum, NDR_IN,
331 &dce_call->pkt.u.request.stub_and_verifier);
332 return NT_STATUS_NET_WRITE_FAULT;
333 }
334
335 return NT_STATUS_OK;
336}
337
338static NTSTATUS rpcecho__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
339{
340 enum ndr_err_code ndr_err;
341 uint16_t opnum = dce_call->pkt.u.request.opnum;
342
343 ndr_err = ndr_table_rpcecho.calls[opnum].ndr_push(push, NDR_OUT, r);
344 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
345 dce_call->fault_code = DCERPC_FAULT_NDR;
346 return NT_STATUS_NET_WRITE_FAULT;
347 }
348
349 return NT_STATUS_OK;
350}
351
352const struct dcesrv_interface dcesrv_rpcecho_interface = {
353 .name = "rpcecho",
354 .syntax_id = {{0x60a15ec5,0x4de8,0x11d7,{0xa6,0x37},{0x00,0x50,0x56,0xa2,0x01,0x82}},1.0},
355 .bind = rpcecho__op_bind,
356 .unbind = rpcecho__op_unbind,
357 .ndr_pull = rpcecho__op_ndr_pull,
358 .dispatch = rpcecho__op_dispatch,
359 .reply = rpcecho__op_reply,
360 .ndr_push = rpcecho__op_ndr_push
361};
362
363
364static NTSTATUS rpcecho__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
365{
366 int i;
367
368 for (i=0;i<ndr_table_rpcecho.endpoints->count;i++) {
369 NTSTATUS ret;
370 const char *name = ndr_table_rpcecho.endpoints->names[i];
371
372 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_rpcecho_interface, NULL);
373 if (!NT_STATUS_IS_OK(ret)) {
374 DEBUG(1,("rpcecho_op_init_server: failed to register endpoint '%s'\n",name));
375 return ret;
376 }
377 }
378
379 return NT_STATUS_OK;
380}
381
382static bool rpcecho__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
383{
384 if (dcesrv_rpcecho_interface.syntax_id.if_version == if_version &&
385 GUID_equal(&dcesrv_rpcecho_interface.syntax_id.uuid, uuid)) {
386 memcpy(iface,&dcesrv_rpcecho_interface, sizeof(*iface));
387 return true;
388 }
389
390 return false;
391}
392
393static bool rpcecho__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
394{
395 if (strcmp(dcesrv_rpcecho_interface.name, name)==0) {
396 memcpy(iface, &dcesrv_rpcecho_interface, sizeof(*iface));
397 return true;
398 }
399
400 return false;
401}
402
403NTSTATUS dcerpc_server_rpcecho_init(void)
404{
405 NTSTATUS ret;
406 struct dcesrv_endpoint_server ep_server;
407
408 /* fill in our name */
409 ep_server.name = "rpcecho";
410
411 /* fill in all the operations */
412 ep_server.init_server = rpcecho__op_init_server;
413
414 ep_server.interface_by_uuid = rpcecho__op_interface_by_uuid;
415 ep_server.interface_by_name = rpcecho__op_interface_by_name;
416
417 /* register ourselves with the DCERPC subsystem. */
418 ret = dcerpc_register_ep_server(&ep_server);
419
420 if (!NT_STATUS_IS_OK(ret)) {
421 DEBUG(0,("Failed to register 'rpcecho' endpoint server!\n"));
422 return ret;
423 }
424
425 return ret;
426}
427
Note: See TracBrowser for help on using the repository browser.