bin/default/librpc/gen_ndr/ndr_frsapi_s.c

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