bin.gen_ndr/default/source4/librpc/gen_ndr/ndr_irpc_s.c

   1 /* server functions auto-generated by pidl */
   2 #include "bin/default/source4/librpc/gen_ndr/ndr_irpc.h"
   3
   4 NTSTATUS dcerpc_server_irpc_init(void);
   5
   6 /* irpc - dcerpc server boilerplate generated by pidl */
   7
   8
   9 static NTSTATUS irpc__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
  10 {
  11 #ifdef DCESRV_INTERFACE_IRPC_BIND
  12         return DCESRV_INTERFACE_IRPC_BIND(dce_call,iface);
  13 #else
  14         return NT_STATUS_OK;
  15 #endif
  16 }
  17
  18 static void irpc__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
  19 {
  20 #ifdef DCESRV_INTERFACE_IRPC_UNBIND
  21         DCESRV_INTERFACE_IRPC_UNBIND(context, iface);
  22 #else
  23         return;
  24 #endif
  25 }
  26
  27 static NTSTATUS irpc__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_irpc.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_irpc.calls[opnum].struct_size,
  41                           "struct %s",
  42                           ndr_table_irpc.calls[opnum].name);
  43         NT_STATUS_HAVE_NO_MEMORY(*r);
  44
  45         /* unravel the NDR for the packet */
  46         ndr_err = ndr_table_irpc.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_irpc, 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 irpc__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 irpc_uptime *r2 = (struct irpc_uptime *)r;
  65                 if (DEBUGLEVEL >= 10) {
  66                         NDR_PRINT_FUNCTION_DEBUG(irpc_uptime, NDR_IN, r2);
  67                 }
  68                 dcesrv_irpc_uptime(dce_call, mem_ctx, r2);
  69                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  70                         DEBUG(5,("function irpc_uptime will reply async\n"));
  71                 }
  72                 break;
  73         }
  74         case 1: {
  75                 struct nbtd_information *r2 = (struct nbtd_information *)r;
  76                 if (DEBUGLEVEL >= 10) {
  77                         NDR_PRINT_FUNCTION_DEBUG(nbtd_information, NDR_IN, r2);
  78                 }
  79                 dcesrv_nbtd_information(dce_call, mem_ctx, r2);
  80                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  81                         DEBUG(5,("function nbtd_information will reply async\n"));
  82                 }
  83                 break;
  84         }
  85         case 2: {
  86                 struct nbtd_getdcname *r2 = (struct nbtd_getdcname *)r;
  87                 if (DEBUGLEVEL >= 10) {
  88                         NDR_PRINT_FUNCTION_DEBUG(nbtd_getdcname, NDR_IN, r2);
  89                 }
  90                 dcesrv_nbtd_getdcname(dce_call, mem_ctx, r2);
  91                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  92                         DEBUG(5,("function nbtd_getdcname will reply async\n"));
  93                 }
  94                 break;
  95         }
  96         case 3: {
  97                 struct nbtd_proxy_wins_challenge *r2 = (struct nbtd_proxy_wins_challenge *)r;
  98                 if (DEBUGLEVEL >= 10) {
  99                         NDR_PRINT_FUNCTION_DEBUG(nbtd_proxy_wins_challenge, NDR_IN, r2);
 100                 }
 101                 dcesrv_nbtd_proxy_wins_challenge(dce_call, mem_ctx, r2);
 102                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 103                         DEBUG(5,("function nbtd_proxy_wins_challenge will reply async\n"));
 104                 }
 105                 break;
 106         }
 107         case 4: {
 108                 struct nbtd_proxy_wins_release_demand *r2 = (struct nbtd_proxy_wins_release_demand *)r;
 109                 if (DEBUGLEVEL >= 10) {
 110                         NDR_PRINT_FUNCTION_DEBUG(nbtd_proxy_wins_release_demand, NDR_IN, r2);
 111                 }
 112                 dcesrv_nbtd_proxy_wins_release_demand(dce_call, mem_ctx, r2);
 113                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 114                         DEBUG(5,("function nbtd_proxy_wins_release_demand will reply async\n"));
 115                 }
 116                 break;
 117         }
 118         case 5: {
 119                 struct kdc_check_generic_kerberos *r2 = (struct kdc_check_generic_kerberos *)r;
 120                 if (DEBUGLEVEL >= 10) {
 121                         NDR_PRINT_FUNCTION_DEBUG(kdc_check_generic_kerberos, NDR_IN, r2);
 122                 }
 123                 dcesrv_kdc_check_generic_kerberos(dce_call, mem_ctx, r2);
 124                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 125                         DEBUG(5,("function kdc_check_generic_kerberos will reply async\n"));
 126                 }
 127                 break;
 128         }
 129         case 6: {
 130                 struct smbsrv_information *r2 = (struct smbsrv_information *)r;
 131                 if (DEBUGLEVEL >= 10) {
 132                         NDR_PRINT_FUNCTION_DEBUG(smbsrv_information, NDR_IN, r2);
 133                 }
 134                 dcesrv_smbsrv_information(dce_call, mem_ctx, r2);
 135                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 136                         DEBUG(5,("function smbsrv_information will reply async\n"));
 137                 }
 138                 break;
 139         }
 140         case 7: {
 141                 struct samba_terminate *r2 = (struct samba_terminate *)r;
 142                 if (DEBUGLEVEL >= 10) {
 143                         NDR_PRINT_FUNCTION_DEBUG(samba_terminate, NDR_IN, r2);
 144                 }
 145                 dcesrv_samba_terminate(dce_call, mem_ctx, r2);
 146                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 147                         DEBUG(5,("function samba_terminate will reply async\n"));
 148                 }
 149                 break;
 150         }
 151         case 8: {
 152                 struct dreplsrv_refresh *r2 = (struct dreplsrv_refresh *)r;
 153                 if (DEBUGLEVEL >= 10) {
 154                         NDR_PRINT_FUNCTION_DEBUG(dreplsrv_refresh, NDR_IN, r2);
 155                 }
 156                 r2->out.result = dcesrv_dreplsrv_refresh(dce_call, mem_ctx, r2);
 157                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 158                         DEBUG(5,("function dreplsrv_refresh will reply async\n"));
 159                 }
 160                 break;
 161         }
 162         case 9: {
 163                 struct drepl_takeFSMORole *r2 = (struct drepl_takeFSMORole *)r;
 164                 if (DEBUGLEVEL >= 10) {
 165                         NDR_PRINT_FUNCTION_DEBUG(drepl_takeFSMORole, NDR_IN, r2);
 166                 }
 167                 r2->out.result = dcesrv_drepl_takeFSMORole(dce_call, mem_ctx, r2);
 168                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 169                         DEBUG(5,("function drepl_takeFSMORole will reply async\n"));
 170                 }
 171                 break;
 172         }
 173         case 10: {
 174                 struct drepl_trigger_repl_secret *r2 = (struct drepl_trigger_repl_secret *)r;
 175                 if (DEBUGLEVEL >= 10) {
 176                         NDR_PRINT_FUNCTION_DEBUG(drepl_trigger_repl_secret, NDR_IN, r2);
 177                 }
 178                 dcesrv_drepl_trigger_repl_secret(dce_call, mem_ctx, r2);
 179                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 180                         DEBUG(5,("function drepl_trigger_repl_secret will reply async\n"));
 181                 }
 182                 break;
 183         }
 184         case 11: {
 185                 struct dnsupdate_RODC *r2 = (struct dnsupdate_RODC *)r;
 186                 if (DEBUGLEVEL >= 10) {
 187                         NDR_PRINT_FUNCTION_DEBUG(dnsupdate_RODC, NDR_IN, r2);
 188                 }
 189                 r2->out.result = dcesrv_dnsupdate_RODC(dce_call, mem_ctx, r2);
 190                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 191                         DEBUG(5,("function dnsupdate_RODC will reply async\n"));
 192                 }
 193                 break;
 194         }
 195
 196         default:
 197                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 198                 break;
 199         }
 200
 201         if (dce_call->fault_code != 0) {
 202                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 203                           &ndr_table_irpc, opnum, NDR_IN,
 204                                   &dce_call->pkt.u.request.stub_and_verifier);
 205                 return NT_STATUS_NET_WRITE_FAULT;
 206         }
 207
 208         return NT_STATUS_OK;
 209 }
 210
 211 static NTSTATUS irpc__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 212 {
 213         uint16_t opnum = dce_call->pkt.u.request.opnum;
 214
 215         switch (opnum) {
 216         case 0: {
 217                 struct irpc_uptime *r2 = (struct irpc_uptime *)r;
 218                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 219                         DEBUG(5,("function irpc_uptime replied async\n"));
 220                 }
 221                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 222                         NDR_PRINT_FUNCTION_DEBUG(irpc_uptime, NDR_OUT | NDR_SET_VALUES, r2);
 223                 }
 224                 if (dce_call->fault_code != 0) {
 225                         DEBUG(2,("dcerpc_fault %s in irpc_uptime\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 226                 }
 227                 break;
 228         }
 229         case 1: {
 230                 struct nbtd_information *r2 = (struct nbtd_information *)r;
 231                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 232                         DEBUG(5,("function nbtd_information replied async\n"));
 233                 }
 234                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 235                         NDR_PRINT_FUNCTION_DEBUG(nbtd_information, NDR_OUT | NDR_SET_VALUES, r2);
 236                 }
 237                 if (dce_call->fault_code != 0) {
 238                         DEBUG(2,("dcerpc_fault %s in nbtd_information\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 239                 }
 240                 break;
 241         }
 242         case 2: {
 243                 struct nbtd_getdcname *r2 = (struct nbtd_getdcname *)r;
 244                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 245                         DEBUG(5,("function nbtd_getdcname replied async\n"));
 246                 }
 247                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 248                         NDR_PRINT_FUNCTION_DEBUG(nbtd_getdcname, NDR_OUT | NDR_SET_VALUES, r2);
 249                 }
 250                 if (dce_call->fault_code != 0) {
 251                         DEBUG(2,("dcerpc_fault %s in nbtd_getdcname\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 252                 }
 253                 break;
 254         }
 255         case 3: {
 256                 struct nbtd_proxy_wins_challenge *r2 = (struct nbtd_proxy_wins_challenge *)r;
 257                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 258                         DEBUG(5,("function nbtd_proxy_wins_challenge replied async\n"));
 259                 }
 260                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 261                         NDR_PRINT_FUNCTION_DEBUG(nbtd_proxy_wins_challenge, NDR_OUT | NDR_SET_VALUES, r2);
 262                 }
 263                 if (dce_call->fault_code != 0) {
 264                         DEBUG(2,("dcerpc_fault %s in nbtd_proxy_wins_challenge\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 265                 }
 266                 break;
 267         }
 268         case 4: {
 269                 struct nbtd_proxy_wins_release_demand *r2 = (struct nbtd_proxy_wins_release_demand *)r;
 270                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 271                         DEBUG(5,("function nbtd_proxy_wins_release_demand replied async\n"));
 272                 }
 273                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 274                         NDR_PRINT_FUNCTION_DEBUG(nbtd_proxy_wins_release_demand, NDR_OUT | NDR_SET_VALUES, r2);
 275                 }
 276                 if (dce_call->fault_code != 0) {
 277                         DEBUG(2,("dcerpc_fault %s in nbtd_proxy_wins_release_demand\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 278                 }
 279                 break;
 280         }
 281         case 5: {
 282                 struct kdc_check_generic_kerberos *r2 = (struct kdc_check_generic_kerberos *)r;
 283                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 284                         DEBUG(5,("function kdc_check_generic_kerberos replied async\n"));
 285                 }
 286                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 287                         NDR_PRINT_FUNCTION_DEBUG(kdc_check_generic_kerberos, NDR_OUT | NDR_SET_VALUES, r2);
 288                 }
 289                 if (dce_call->fault_code != 0) {
 290                         DEBUG(2,("dcerpc_fault %s in kdc_check_generic_kerberos\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 291                 }
 292                 break;
 293         }
 294         case 6: {
 295                 struct smbsrv_information *r2 = (struct smbsrv_information *)r;
 296                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 297                         DEBUG(5,("function smbsrv_information replied async\n"));
 298                 }
 299                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 300                         NDR_PRINT_FUNCTION_DEBUG(smbsrv_information, NDR_OUT | NDR_SET_VALUES, r2);
 301                 }
 302                 if (dce_call->fault_code != 0) {
 303                         DEBUG(2,("dcerpc_fault %s in smbsrv_information\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 304                 }
 305                 break;
 306         }
 307         case 7: {
 308                 struct samba_terminate *r2 = (struct samba_terminate *)r;
 309                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 310                         DEBUG(5,("function samba_terminate replied async\n"));
 311                 }
 312                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 313                         NDR_PRINT_FUNCTION_DEBUG(samba_terminate, NDR_OUT | NDR_SET_VALUES, r2);
 314                 }
 315                 if (dce_call->fault_code != 0) {
 316                         DEBUG(2,("dcerpc_fault %s in samba_terminate\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 317                 }
 318                 break;
 319         }
 320         case 8: {
 321                 struct dreplsrv_refresh *r2 = (struct dreplsrv_refresh *)r;
 322                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 323                         DEBUG(5,("function dreplsrv_refresh replied async\n"));
 324                 }
 325                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 326                         NDR_PRINT_FUNCTION_DEBUG(dreplsrv_refresh, NDR_OUT | NDR_SET_VALUES, r2);
 327                 }
 328                 if (dce_call->fault_code != 0) {
 329                         DEBUG(2,("dcerpc_fault %s in dreplsrv_refresh\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 330                 }
 331                 break;
 332         }
 333         case 9: {
 334                 struct drepl_takeFSMORole *r2 = (struct drepl_takeFSMORole *)r;
 335                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 336                         DEBUG(5,("function drepl_takeFSMORole replied async\n"));
 337                 }
 338                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 339                         NDR_PRINT_FUNCTION_DEBUG(drepl_takeFSMORole, NDR_OUT | NDR_SET_VALUES, r2);
 340                 }
 341                 if (dce_call->fault_code != 0) {
 342                         DEBUG(2,("dcerpc_fault %s in drepl_takeFSMORole\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 343                 }
 344                 break;
 345         }
 346         case 10: {
 347                 struct drepl_trigger_repl_secret *r2 = (struct drepl_trigger_repl_secret *)r;
 348                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 349                         DEBUG(5,("function drepl_trigger_repl_secret replied async\n"));
 350                 }
 351                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 352                         NDR_PRINT_FUNCTION_DEBUG(drepl_trigger_repl_secret, NDR_OUT | NDR_SET_VALUES, r2);
 353                 }
 354                 if (dce_call->fault_code != 0) {
 355                         DEBUG(2,("dcerpc_fault %s in drepl_trigger_repl_secret\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 356                 }
 357                 break;
 358         }
 359         case 11: {
 360                 struct dnsupdate_RODC *r2 = (struct dnsupdate_RODC *)r;
 361                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 362                         DEBUG(5,("function dnsupdate_RODC replied async\n"));
 363                 }
 364                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 365                         NDR_PRINT_FUNCTION_DEBUG(dnsupdate_RODC, NDR_OUT | NDR_SET_VALUES, r2);
 366                 }
 367                 if (dce_call->fault_code != 0) {
 368                         DEBUG(2,("dcerpc_fault %s in dnsupdate_RODC\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 369                 }
 370                 break;
 371         }
 372
 373         default:
 374                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 375                 break;
 376         }
 377
 378         if (dce_call->fault_code != 0) {
 379                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 380                           &ndr_table_irpc, opnum, NDR_IN,
 381                                   &dce_call->pkt.u.request.stub_and_verifier);
 382                 return NT_STATUS_NET_WRITE_FAULT;
 383         }
 384
 385         return NT_STATUS_OK;
 386 }
 387
 388 static NTSTATUS irpc__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
 389 {
 390         enum ndr_err_code ndr_err;
 391         uint16_t opnum = dce_call->pkt.u.request.opnum;
 392
 393         ndr_err = ndr_table_irpc.calls[opnum].ndr_push(push, NDR_OUT, r);
 394         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 395                 dce_call->fault_code = DCERPC_FAULT_NDR;
 396                 return NT_STATUS_NET_WRITE_FAULT;
 397         }
 398
 399         return NT_STATUS_OK;
 400 }
 401
 402 const struct dcesrv_interface dcesrv_irpc_interface = {
 403         .name           = "irpc",
 404         .syntax_id  = {{0xe770c620,0x0b06,0x4b5e,{0x8d,0x87},{0xa2,0x6e,0x20,0xf2,0x83,0x40}},1.0},
 405         .bind           = irpc__op_bind,
 406         .unbind         = irpc__op_unbind,
 407         .ndr_pull       = irpc__op_ndr_pull,
 408         .dispatch       = irpc__op_dispatch,
 409         .reply          = irpc__op_reply,
 410         .ndr_push       = irpc__op_ndr_push
 411 };
 412
 413
 414 static NTSTATUS irpc__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
 415 {
 416         int i;
 417
 418         for (i=0;i<ndr_table_irpc.endpoints->count;i++) {
 419                 NTSTATUS ret;
 420                 const char *name = ndr_table_irpc.endpoints->names[i];
 421
 422                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_irpc_interface, NULL);
 423                 if (!NT_STATUS_IS_OK(ret)) {
 424                         DEBUG(1,("irpc_op_init_server: failed to register endpoint '%s'\n",name));
 425                         return ret;
 426                 }
 427         }
 428
 429         return NT_STATUS_OK;
 430 }
 431
 432 static bool irpc__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
 433 {
 434         if (dcesrv_irpc_interface.syntax_id.if_version == if_version &&
 435                 GUID_equal(&dcesrv_irpc_interface.syntax_id.uuid, uuid)) {
 436                 memcpy(iface,&dcesrv_irpc_interface, sizeof(*iface));
 437                 return true;
 438         }
 439
 440         return false;
 441 }
 442
 443 static bool irpc__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
 444 {
 445         if (strcmp(dcesrv_irpc_interface.name, name)==0) {
 446                 memcpy(iface, &dcesrv_irpc_interface, sizeof(*iface));
 447                 return true;
 448         }
 449
 450         return false;
 451 }
 452
 453 NTSTATUS dcerpc_server_irpc_init(void)
 454 {
 455         NTSTATUS ret;
 456         struct dcesrv_endpoint_server ep_server;
 457
 458         /* fill in our name */
 459         ep_server.name = "irpc";
 460
 461         /* fill in all the operations */
 462         ep_server.init_server = irpc__op_init_server;
 463
 464         ep_server.interface_by_uuid = irpc__op_interface_by_uuid;
 465         ep_server.interface_by_name = irpc__op_interface_by_name;
 466
 467         /* register ourselves with the DCERPC subsystem. */
 468         ret = dcerpc_register_ep_server(&ep_server);
 469
 470         if (!NT_STATUS_IS_OK(ret)) {
 471                 DEBUG(0,("Failed to register 'irpc' endpoint server!\n"));
 472                 return ret;
 473         }
 474
 475         return ret;
 476 }
 477