bin.gen_ndr/default/librpc/gen_ndr/ndr_dcom_s.c

   1 /* server functions auto-generated by pidl */
   2 #include "bin/default/librpc/gen_ndr/ndr_dcom.h"
   3
   4 NTSTATUS dcerpc_server_dcom_Unknown_init(void);
   5
   6 /* dcom_Unknown - dcerpc server boilerplate generated by pidl */
   7
   8
   9 static NTSTATUS dcom_Unknown__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
  10 {
  11 #ifdef DCESRV_INTERFACE_DCOM_UNKNOWN_BIND
  12         return DCESRV_INTERFACE_DCOM_UNKNOWN_BIND(dce_call,iface);
  13 #else
  14         return NT_STATUS_OK;
  15 #endif
  16 }
  17
  18 static void dcom_Unknown__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
  19 {
  20 #ifdef DCESRV_INTERFACE_DCOM_UNKNOWN_UNBIND
  21         DCESRV_INTERFACE_DCOM_UNKNOWN_UNBIND(context, iface);
  22 #else
  23         return;
  24 #endif
  25 }
  26
  27 static NTSTATUS dcom_Unknown__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
  28 {
  29         enum ndr_err_code ndr_err;
  30         uint16_t opnum = dce_call->pkt.u.request.opnum;
  31
  32         dce_call->fault_code = 0;
  33
  34         if (opnum >= ndr_table_dcom_Unknown.num_calls) {
  35                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
  36                 return NT_STATUS_NET_WRITE_FAULT;
  37         }
  38
  39         *r = talloc_named(mem_ctx,
  40                           ndr_table_dcom_Unknown.calls[opnum].struct_size,
  41                           "struct %s",
  42                           ndr_table_dcom_Unknown.calls[opnum].name);
  43         NT_STATUS_HAVE_NO_MEMORY(*r);
  44
  45         /* unravel the NDR for the packet */
  46         ndr_err = ndr_table_dcom_Unknown.calls[opnum].ndr_pull(pull, NDR_IN, *r);
  47         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  48                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
  49                                   &ndr_table_dcom_Unknown, opnum, NDR_IN,
  50                                   &dce_call->pkt.u.request.stub_and_verifier);
  51                 dce_call->fault_code = DCERPC_FAULT_NDR;
  52                 return NT_STATUS_NET_WRITE_FAULT;
  53         }
  54
  55         return NT_STATUS_OK;
  56 }
  57
  58 static NTSTATUS dcom_Unknown__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
  59 {
  60         uint16_t opnum = dce_call->pkt.u.request.opnum;
  61
  62         switch (opnum) {
  63         case 0: {
  64                 struct UseProtSeq *r2 = (struct UseProtSeq *)r;
  65                 if (DEBUGLEVEL >= 10) {
  66                         NDR_PRINT_FUNCTION_DEBUG(UseProtSeq, NDR_IN, r2);
  67                 }
  68                 dcesrv_UseProtSeq(dce_call, mem_ctx, r2);
  69                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  70                         DEBUG(5,("function UseProtSeq will reply async\n"));
  71                 }
  72                 break;
  73         }
  74         case 1: {
  75                 struct GetCustomProtseqInfo *r2 = (struct GetCustomProtseqInfo *)r;
  76                 if (DEBUGLEVEL >= 10) {
  77                         NDR_PRINT_FUNCTION_DEBUG(GetCustomProtseqInfo, NDR_IN, r2);
  78                 }
  79                 dcesrv_GetCustomProtseqInfo(dce_call, mem_ctx, r2);
  80                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  81                         DEBUG(5,("function GetCustomProtseqInfo will reply async\n"));
  82                 }
  83                 break;
  84         }
  85         case 2: {
  86                 struct UpdateResolverBindings *r2 = (struct UpdateResolverBindings *)r;
  87                 if (DEBUGLEVEL >= 10) {
  88                         NDR_PRINT_FUNCTION_DEBUG(UpdateResolverBindings, NDR_IN, r2);
  89                 }
  90                 dcesrv_UpdateResolverBindings(dce_call, mem_ctx, r2);
  91                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  92                         DEBUG(5,("function UpdateResolverBindings will reply async\n"));
  93                 }
  94                 break;
  95         }
  96
  97         default:
  98                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
  99                 break;
 100         }
 101
 102         if (dce_call->fault_code != 0) {
 103                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 104                           &ndr_table_dcom_Unknown, opnum, NDR_IN,
 105                                   &dce_call->pkt.u.request.stub_and_verifier);
 106                 return NT_STATUS_NET_WRITE_FAULT;
 107         }
 108
 109         return NT_STATUS_OK;
 110 }
 111
 112 static NTSTATUS dcom_Unknown__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 113 {
 114         uint16_t opnum = dce_call->pkt.u.request.opnum;
 115
 116         switch (opnum) {
 117         case 0: {
 118                 struct UseProtSeq *r2 = (struct UseProtSeq *)r;
 119                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 120                         DEBUG(5,("function UseProtSeq replied async\n"));
 121                 }
 122                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 123                         NDR_PRINT_FUNCTION_DEBUG(UseProtSeq, NDR_OUT | NDR_SET_VALUES, r2);
 124                 }
 125                 if (dce_call->fault_code != 0) {
 126                         DEBUG(2,("dcerpc_fault %s in UseProtSeq\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 127                 }
 128                 break;
 129         }
 130         case 1: {
 131                 struct GetCustomProtseqInfo *r2 = (struct GetCustomProtseqInfo *)r;
 132                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 133                         DEBUG(5,("function GetCustomProtseqInfo replied async\n"));
 134                 }
 135                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 136                         NDR_PRINT_FUNCTION_DEBUG(GetCustomProtseqInfo, NDR_OUT | NDR_SET_VALUES, r2);
 137                 }
 138                 if (dce_call->fault_code != 0) {
 139                         DEBUG(2,("dcerpc_fault %s in GetCustomProtseqInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 140                 }
 141                 break;
 142         }
 143         case 2: {
 144                 struct UpdateResolverBindings *r2 = (struct UpdateResolverBindings *)r;
 145                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 146                         DEBUG(5,("function UpdateResolverBindings replied async\n"));
 147                 }
 148                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 149                         NDR_PRINT_FUNCTION_DEBUG(UpdateResolverBindings, NDR_OUT | NDR_SET_VALUES, r2);
 150                 }
 151                 if (dce_call->fault_code != 0) {
 152                         DEBUG(2,("dcerpc_fault %s in UpdateResolverBindings\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 153                 }
 154                 break;
 155         }
 156
 157         default:
 158                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 159                 break;
 160         }
 161
 162         if (dce_call->fault_code != 0) {
 163                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 164                           &ndr_table_dcom_Unknown, opnum, NDR_IN,
 165                                   &dce_call->pkt.u.request.stub_and_verifier);
 166                 return NT_STATUS_NET_WRITE_FAULT;
 167         }
 168
 169         return NT_STATUS_OK;
 170 }
 171
 172 static NTSTATUS dcom_Unknown__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
 173 {
 174         enum ndr_err_code ndr_err;
 175         uint16_t opnum = dce_call->pkt.u.request.opnum;
 176
 177         ndr_err = ndr_table_dcom_Unknown.calls[opnum].ndr_push(push, NDR_OUT, r);
 178         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 179                 dce_call->fault_code = DCERPC_FAULT_NDR;
 180                 return NT_STATUS_NET_WRITE_FAULT;
 181         }
 182
 183         return NT_STATUS_OK;
 184 }
 185
 186 const struct dcesrv_interface dcesrv_dcom_Unknown_interface = {
 187         .name           = "dcom_Unknown",
 188         .syntax_id  = {{0x18f70770,0x8e64,0x11cf,{0x9a,0xf1},{0x00,0x20,0xaf,0x6e,0x72,0xf4}},0.0},
 189         .bind           = dcom_Unknown__op_bind,
 190         .unbind         = dcom_Unknown__op_unbind,
 191         .ndr_pull       = dcom_Unknown__op_ndr_pull,
 192         .dispatch       = dcom_Unknown__op_dispatch,
 193         .reply          = dcom_Unknown__op_reply,
 194         .ndr_push       = dcom_Unknown__op_ndr_push
 195 };
 196
 197
 198 static NTSTATUS dcom_Unknown__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
 199 {
 200         int i;
 201
 202         for (i=0;i<ndr_table_dcom_Unknown.endpoints->count;i++) {
 203                 NTSTATUS ret;
 204                 const char *name = ndr_table_dcom_Unknown.endpoints->names[i];
 205
 206                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_dcom_Unknown_interface, NULL);
 207                 if (!NT_STATUS_IS_OK(ret)) {
 208                         DEBUG(1,("dcom_Unknown_op_init_server: failed to register endpoint '%s'\n",name));
 209                         return ret;
 210                 }
 211         }
 212
 213         return NT_STATUS_OK;
 214 }
 215
 216 static bool dcom_Unknown__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
 217 {
 218         if (dcesrv_dcom_Unknown_interface.syntax_id.if_version == if_version &&
 219                 GUID_equal(&dcesrv_dcom_Unknown_interface.syntax_id.uuid, uuid)) {
 220                 memcpy(iface,&dcesrv_dcom_Unknown_interface, sizeof(*iface));
 221                 return true;
 222         }
 223
 224         return false;
 225 }
 226
 227 static bool dcom_Unknown__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
 228 {
 229         if (strcmp(dcesrv_dcom_Unknown_interface.name, name)==0) {
 230                 memcpy(iface, &dcesrv_dcom_Unknown_interface, sizeof(*iface));
 231                 return true;
 232         }
 233
 234         return false;
 235 }
 236
 237 NTSTATUS dcerpc_server_dcom_Unknown_init(void)
 238 {
 239         NTSTATUS ret;
 240         struct dcesrv_endpoint_server ep_server;
 241
 242         /* fill in our name */
 243         ep_server.name = "dcom_Unknown";
 244
 245         /* fill in all the operations */
 246         ep_server.init_server = dcom_Unknown__op_init_server;
 247
 248         ep_server.interface_by_uuid = dcom_Unknown__op_interface_by_uuid;
 249         ep_server.interface_by_name = dcom_Unknown__op_interface_by_name;
 250
 251         /* register ourselves with the DCERPC subsystem. */
 252         ret = dcerpc_register_ep_server(&ep_server);
 253
 254         if (!NT_STATUS_IS_OK(ret)) {
 255                 DEBUG(0,("Failed to register 'dcom_Unknown' endpoint server!\n"));
 256                 return ret;
 257         }
 258
 259         return ret;
 260 }
 261
 262 NTSTATUS dcerpc_server_IMachineLocalActivator_init(void);
 263
 264 /* IMachineLocalActivator - dcerpc server boilerplate generated by pidl */
 265
 266
 267 static NTSTATUS IMachineLocalActivator__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
 268 {
 269 #ifdef DCESRV_INTERFACE_IMACHINELOCALACTIVATOR_BIND
 270         return DCESRV_INTERFACE_IMACHINELOCALACTIVATOR_BIND(dce_call,iface);
 271 #else
 272         return NT_STATUS_OK;
 273 #endif
 274 }
 275
 276 static void IMachineLocalActivator__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
 277 {
 278 #ifdef DCESRV_INTERFACE_IMACHINELOCALACTIVATOR_UNBIND
 279         DCESRV_INTERFACE_IMACHINELOCALACTIVATOR_UNBIND(context, iface);
 280 #else
 281         return;
 282 #endif
 283 }
 284
 285 static NTSTATUS IMachineLocalActivator__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
 286 {
 287         enum ndr_err_code ndr_err;
 288         uint16_t opnum = dce_call->pkt.u.request.opnum;
 289
 290         dce_call->fault_code = 0;
 291
 292         if (opnum >= ndr_table_IMachineLocalActivator.num_calls) {
 293                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 294                 return NT_STATUS_NET_WRITE_FAULT;
 295         }
 296
 297         *r = talloc_named(mem_ctx,
 298                           ndr_table_IMachineLocalActivator.calls[opnum].struct_size,
 299                           "struct %s",
 300                           ndr_table_IMachineLocalActivator.calls[opnum].name);
 301         NT_STATUS_HAVE_NO_MEMORY(*r);
 302
 303         /* unravel the NDR for the packet */
 304         ndr_err = ndr_table_IMachineLocalActivator.calls[opnum].ndr_pull(pull, NDR_IN, *r);
 305         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 306                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 307                                   &ndr_table_IMachineLocalActivator, opnum, NDR_IN,
 308                                   &dce_call->pkt.u.request.stub_and_verifier);
 309                 dce_call->fault_code = DCERPC_FAULT_NDR;
 310                 return NT_STATUS_NET_WRITE_FAULT;
 311         }
 312
 313         return NT_STATUS_OK;
 314 }
 315
 316 static NTSTATUS IMachineLocalActivator__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 317 {
 318         uint16_t opnum = dce_call->pkt.u.request.opnum;
 319
 320         switch (opnum) {
 321         case 0: {
 322                 struct IMachineLocalActivator_foo *r2 = (struct IMachineLocalActivator_foo *)r;
 323                 if (DEBUGLEVEL >= 10) {
 324                         NDR_PRINT_FUNCTION_DEBUG(IMachineLocalActivator_foo, NDR_IN, r2);
 325                 }
 326                 r2->out.result = dcesrv_IMachineLocalActivator_foo(dce_call, mem_ctx, r2);
 327                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 328                         DEBUG(5,("function IMachineLocalActivator_foo will reply async\n"));
 329                 }
 330                 break;
 331         }
 332
 333         default:
 334                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 335                 break;
 336         }
 337
 338         if (dce_call->fault_code != 0) {
 339                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 340                           &ndr_table_IMachineLocalActivator, opnum, NDR_IN,
 341                                   &dce_call->pkt.u.request.stub_and_verifier);
 342                 return NT_STATUS_NET_WRITE_FAULT;
 343         }
 344
 345         return NT_STATUS_OK;
 346 }
 347
 348 static NTSTATUS IMachineLocalActivator__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 349 {
 350         uint16_t opnum = dce_call->pkt.u.request.opnum;
 351
 352         switch (opnum) {
 353         case 0: {
 354                 struct IMachineLocalActivator_foo *r2 = (struct IMachineLocalActivator_foo *)r;
 355                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 356                         DEBUG(5,("function IMachineLocalActivator_foo replied async\n"));
 357                 }
 358                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 359                         NDR_PRINT_FUNCTION_DEBUG(IMachineLocalActivator_foo, NDR_OUT | NDR_SET_VALUES, r2);
 360                 }
 361                 if (dce_call->fault_code != 0) {
 362                         DEBUG(2,("dcerpc_fault %s in IMachineLocalActivator_foo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 363                 }
 364                 break;
 365         }
 366
 367         default:
 368                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 369                 break;
 370         }
 371
 372         if (dce_call->fault_code != 0) {
 373                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 374                           &ndr_table_IMachineLocalActivator, opnum, NDR_IN,
 375                                   &dce_call->pkt.u.request.stub_and_verifier);
 376                 return NT_STATUS_NET_WRITE_FAULT;
 377         }
 378
 379         return NT_STATUS_OK;
 380 }
 381
 382 static NTSTATUS IMachineLocalActivator__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
 383 {
 384         enum ndr_err_code ndr_err;
 385         uint16_t opnum = dce_call->pkt.u.request.opnum;
 386
 387         ndr_err = ndr_table_IMachineLocalActivator.calls[opnum].ndr_push(push, NDR_OUT, r);
 388         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 389                 dce_call->fault_code = DCERPC_FAULT_NDR;
 390                 return NT_STATUS_NET_WRITE_FAULT;
 391         }
 392
 393         return NT_STATUS_OK;
 394 }
 395
 396 const struct dcesrv_interface dcesrv_IMachineLocalActivator_interface = {
 397         .name           = "IMachineLocalActivator",
 398         .syntax_id  = {{0xc6f3ee72,0xce7e,0x11d1,{0xb7,0x1e},{0x00,0xc0,0x4f,0xc3,0x11,0x1a}},0.0},
 399         .bind           = IMachineLocalActivator__op_bind,
 400         .unbind         = IMachineLocalActivator__op_unbind,
 401         .ndr_pull       = IMachineLocalActivator__op_ndr_pull,
 402         .dispatch       = IMachineLocalActivator__op_dispatch,
 403         .reply          = IMachineLocalActivator__op_reply,
 404         .ndr_push       = IMachineLocalActivator__op_ndr_push
 405 };
 406
 407
 408 static NTSTATUS IMachineLocalActivator__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
 409 {
 410         int i;
 411
 412         for (i=0;i<ndr_table_IMachineLocalActivator.endpoints->count;i++) {
 413                 NTSTATUS ret;
 414                 const char *name = ndr_table_IMachineLocalActivator.endpoints->names[i];
 415
 416                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_IMachineLocalActivator_interface, NULL);
 417                 if (!NT_STATUS_IS_OK(ret)) {
 418                         DEBUG(1,("IMachineLocalActivator_op_init_server: failed to register endpoint '%s'\n",name));
 419                         return ret;
 420                 }
 421         }
 422
 423         return NT_STATUS_OK;
 424 }
 425
 426 static bool IMachineLocalActivator__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
 427 {
 428         if (dcesrv_IMachineLocalActivator_interface.syntax_id.if_version == if_version &&
 429                 GUID_equal(&dcesrv_IMachineLocalActivator_interface.syntax_id.uuid, uuid)) {
 430                 memcpy(iface,&dcesrv_IMachineLocalActivator_interface, sizeof(*iface));
 431                 return true;
 432         }
 433
 434         return false;
 435 }
 436
 437 static bool IMachineLocalActivator__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
 438 {
 439         if (strcmp(dcesrv_IMachineLocalActivator_interface.name, name)==0) {
 440                 memcpy(iface, &dcesrv_IMachineLocalActivator_interface, sizeof(*iface));
 441                 return true;
 442         }
 443
 444         return false;
 445 }
 446
 447 NTSTATUS dcerpc_server_IMachineLocalActivator_init(void)
 448 {
 449         NTSTATUS ret;
 450         struct dcesrv_endpoint_server ep_server;
 451
 452         /* fill in our name */
 453         ep_server.name = "IMachineLocalActivator";
 454
 455         /* fill in all the operations */
 456         ep_server.init_server = IMachineLocalActivator__op_init_server;
 457
 458         ep_server.interface_by_uuid = IMachineLocalActivator__op_interface_by_uuid;
 459         ep_server.interface_by_name = IMachineLocalActivator__op_interface_by_name;
 460
 461         /* register ourselves with the DCERPC subsystem. */
 462         ret = dcerpc_register_ep_server(&ep_server);
 463
 464         if (!NT_STATUS_IS_OK(ret)) {
 465                 DEBUG(0,("Failed to register 'IMachineLocalActivator' endpoint server!\n"));
 466                 return ret;
 467         }
 468
 469         return ret;
 470 }
 471
 472 NTSTATUS dcerpc_server_ILocalObjectExporter_init(void);
 473
 474 /* ILocalObjectExporter - dcerpc server boilerplate generated by pidl */
 475
 476
 477 static NTSTATUS ILocalObjectExporter__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
 478 {
 479 #ifdef DCESRV_INTERFACE_ILOCALOBJECTEXPORTER_BIND
 480         return DCESRV_INTERFACE_ILOCALOBJECTEXPORTER_BIND(dce_call,iface);
 481 #else
 482         return NT_STATUS_OK;
 483 #endif
 484 }
 485
 486 static void ILocalObjectExporter__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
 487 {
 488 #ifdef DCESRV_INTERFACE_ILOCALOBJECTEXPORTER_UNBIND
 489         DCESRV_INTERFACE_ILOCALOBJECTEXPORTER_UNBIND(context, iface);
 490 #else
 491         return;
 492 #endif
 493 }
 494
 495 static NTSTATUS ILocalObjectExporter__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
 496 {
 497         enum ndr_err_code ndr_err;
 498         uint16_t opnum = dce_call->pkt.u.request.opnum;
 499
 500         dce_call->fault_code = 0;
 501
 502         if (opnum >= ndr_table_ILocalObjectExporter.num_calls) {
 503                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 504                 return NT_STATUS_NET_WRITE_FAULT;
 505         }
 506
 507         *r = talloc_named(mem_ctx,
 508                           ndr_table_ILocalObjectExporter.calls[opnum].struct_size,
 509                           "struct %s",
 510                           ndr_table_ILocalObjectExporter.calls[opnum].name);
 511         NT_STATUS_HAVE_NO_MEMORY(*r);
 512
 513         /* unravel the NDR for the packet */
 514         ndr_err = ndr_table_ILocalObjectExporter.calls[opnum].ndr_pull(pull, NDR_IN, *r);
 515         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 516                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 517                                   &ndr_table_ILocalObjectExporter, opnum, NDR_IN,
 518                                   &dce_call->pkt.u.request.stub_and_verifier);
 519                 dce_call->fault_code = DCERPC_FAULT_NDR;
 520                 return NT_STATUS_NET_WRITE_FAULT;
 521         }
 522
 523         return NT_STATUS_OK;
 524 }
 525
 526 static NTSTATUS ILocalObjectExporter__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 527 {
 528         uint16_t opnum = dce_call->pkt.u.request.opnum;
 529
 530         switch (opnum) {
 531         case 0: {
 532                 struct ILocalObjectExporter_Foo *r2 = (struct ILocalObjectExporter_Foo *)r;
 533                 if (DEBUGLEVEL >= 10) {
 534                         NDR_PRINT_FUNCTION_DEBUG(ILocalObjectExporter_Foo, NDR_IN, r2);
 535                 }
 536                 r2->out.result = dcesrv_ILocalObjectExporter_Foo(dce_call, mem_ctx, r2);
 537                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 538                         DEBUG(5,("function ILocalObjectExporter_Foo will reply async\n"));
 539                 }
 540                 break;
 541         }
 542
 543         default:
 544                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 545                 break;
 546         }
 547
 548         if (dce_call->fault_code != 0) {
 549                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 550                           &ndr_table_ILocalObjectExporter, opnum, NDR_IN,
 551                                   &dce_call->pkt.u.request.stub_and_verifier);
 552                 return NT_STATUS_NET_WRITE_FAULT;
 553         }
 554
 555         return NT_STATUS_OK;
 556 }
 557
 558 static NTSTATUS ILocalObjectExporter__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 559 {
 560         uint16_t opnum = dce_call->pkt.u.request.opnum;
 561
 562         switch (opnum) {
 563         case 0: {
 564                 struct ILocalObjectExporter_Foo *r2 = (struct ILocalObjectExporter_Foo *)r;
 565                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 566                         DEBUG(5,("function ILocalObjectExporter_Foo replied async\n"));
 567                 }
 568                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 569                         NDR_PRINT_FUNCTION_DEBUG(ILocalObjectExporter_Foo, NDR_OUT | NDR_SET_VALUES, r2);
 570                 }
 571                 if (dce_call->fault_code != 0) {
 572                         DEBUG(2,("dcerpc_fault %s in ILocalObjectExporter_Foo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 573                 }
 574                 break;
 575         }
 576
 577         default:
 578                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 579                 break;
 580         }
 581
 582         if (dce_call->fault_code != 0) {
 583                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 584                           &ndr_table_ILocalObjectExporter, opnum, NDR_IN,
 585                                   &dce_call->pkt.u.request.stub_and_verifier);
 586                 return NT_STATUS_NET_WRITE_FAULT;
 587         }
 588
 589         return NT_STATUS_OK;
 590 }
 591
 592 static NTSTATUS ILocalObjectExporter__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
 593 {
 594         enum ndr_err_code ndr_err;
 595         uint16_t opnum = dce_call->pkt.u.request.opnum;
 596
 597         ndr_err = ndr_table_ILocalObjectExporter.calls[opnum].ndr_push(push, NDR_OUT, r);
 598         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 599                 dce_call->fault_code = DCERPC_FAULT_NDR;
 600                 return NT_STATUS_NET_WRITE_FAULT;
 601         }
 602
 603         return NT_STATUS_OK;
 604 }
 605
 606 const struct dcesrv_interface dcesrv_ILocalObjectExporter_interface = {
 607         .name           = "ILocalObjectExporter",
 608         .syntax_id  = {{0xe60c73e6,0x88f9,0x11cf,{0x9a,0xf1},{0x00,0x20,0xaf,0x6e,0x72,0xf4}},0.0},
 609         .bind           = ILocalObjectExporter__op_bind,
 610         .unbind         = ILocalObjectExporter__op_unbind,
 611         .ndr_pull       = ILocalObjectExporter__op_ndr_pull,
 612         .dispatch       = ILocalObjectExporter__op_dispatch,
 613         .reply          = ILocalObjectExporter__op_reply,
 614         .ndr_push       = ILocalObjectExporter__op_ndr_push
 615 };
 616
 617
 618 static NTSTATUS ILocalObjectExporter__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
 619 {
 620         int i;
 621
 622         for (i=0;i<ndr_table_ILocalObjectExporter.endpoints->count;i++) {
 623                 NTSTATUS ret;
 624                 const char *name = ndr_table_ILocalObjectExporter.endpoints->names[i];
 625
 626                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_ILocalObjectExporter_interface, NULL);
 627                 if (!NT_STATUS_IS_OK(ret)) {
 628                         DEBUG(1,("ILocalObjectExporter_op_init_server: failed to register endpoint '%s'\n",name));
 629                         return ret;
 630                 }
 631         }
 632
 633         return NT_STATUS_OK;
 634 }
 635
 636 static bool ILocalObjectExporter__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
 637 {
 638         if (dcesrv_ILocalObjectExporter_interface.syntax_id.if_version == if_version &&
 639                 GUID_equal(&dcesrv_ILocalObjectExporter_interface.syntax_id.uuid, uuid)) {
 640                 memcpy(iface,&dcesrv_ILocalObjectExporter_interface, sizeof(*iface));
 641                 return true;
 642         }
 643
 644         return false;
 645 }
 646
 647 static bool ILocalObjectExporter__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
 648 {
 649         if (strcmp(dcesrv_ILocalObjectExporter_interface.name, name)==0) {
 650                 memcpy(iface, &dcesrv_ILocalObjectExporter_interface, sizeof(*iface));
 651                 return true;
 652         }
 653
 654         return false;
 655 }
 656
 657 NTSTATUS dcerpc_server_ILocalObjectExporter_init(void)
 658 {
 659         NTSTATUS ret;
 660         struct dcesrv_endpoint_server ep_server;
 661
 662         /* fill in our name */
 663         ep_server.name = "ILocalObjectExporter";
 664
 665         /* fill in all the operations */
 666         ep_server.init_server = ILocalObjectExporter__op_init_server;
 667
 668         ep_server.interface_by_uuid = ILocalObjectExporter__op_interface_by_uuid;
 669         ep_server.interface_by_name = ILocalObjectExporter__op_interface_by_name;
 670
 671         /* register ourselves with the DCERPC subsystem. */
 672         ret = dcerpc_register_ep_server(&ep_server);
 673
 674         if (!NT_STATUS_IS_OK(ret)) {
 675                 DEBUG(0,("Failed to register 'ILocalObjectExporter' endpoint server!\n"));
 676                 return ret;
 677         }
 678
 679         return ret;
 680 }
 681