bin.gen_ndr/default/librpc/gen_ndr/ndr_efs_s.c

   1 /* server functions auto-generated by pidl */
   2 #include "bin/default/librpc/gen_ndr/ndr_efs.h"
   3
   4 NTSTATUS dcerpc_server_efs_init(void);
   5
   6 /* efs - dcerpc server boilerplate generated by pidl */
   7
   8
   9 static NTSTATUS efs__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
  10 {
  11 #ifdef DCESRV_INTERFACE_EFS_BIND
  12         return DCESRV_INTERFACE_EFS_BIND(dce_call,iface);
  13 #else
  14         return NT_STATUS_OK;
  15 #endif
  16 }
  17
  18 static void efs__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
  19 {
  20 #ifdef DCESRV_INTERFACE_EFS_UNBIND
  21         DCESRV_INTERFACE_EFS_UNBIND(context, iface);
  22 #else
  23         return;
  24 #endif
  25 }
  26
  27 static NTSTATUS efs__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_efs.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_efs.calls[opnum].struct_size,
  41                           "struct %s",
  42                           ndr_table_efs.calls[opnum].name);
  43         NT_STATUS_HAVE_NO_MEMORY(*r);
  44
  45         /* unravel the NDR for the packet */
  46         ndr_err = ndr_table_efs.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_efs, 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 efs__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 EfsRpcOpenFileRaw *r2 = (struct EfsRpcOpenFileRaw *)r;
  65                 if (DEBUGLEVEL >= 10) {
  66                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcOpenFileRaw, NDR_IN, r2);
  67                 }
  68                 r2->out.result = dcesrv_EfsRpcOpenFileRaw(dce_call, mem_ctx, r2);
  69                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  70                         DEBUG(5,("function EfsRpcOpenFileRaw will reply async\n"));
  71                 }
  72                 break;
  73         }
  74         case 1: {
  75                 struct EfsRpcReadFileRaw *r2 = (struct EfsRpcReadFileRaw *)r;
  76                 if (DEBUGLEVEL >= 10) {
  77                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcReadFileRaw, NDR_IN, r2);
  78                 }
  79                 r2->out.result = dcesrv_EfsRpcReadFileRaw(dce_call, mem_ctx, r2);
  80                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  81                         DEBUG(5,("function EfsRpcReadFileRaw will reply async\n"));
  82                 }
  83                 break;
  84         }
  85         case 2: {
  86                 struct EfsRpcWriteFileRaw *r2 = (struct EfsRpcWriteFileRaw *)r;
  87                 if (DEBUGLEVEL >= 10) {
  88                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcWriteFileRaw, NDR_IN, r2);
  89                 }
  90                 r2->out.result = dcesrv_EfsRpcWriteFileRaw(dce_call, mem_ctx, r2);
  91                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  92                         DEBUG(5,("function EfsRpcWriteFileRaw will reply async\n"));
  93                 }
  94                 break;
  95         }
  96         case 3: {
  97                 struct EfsRpcCloseRaw *r2 = (struct EfsRpcCloseRaw *)r;
  98                 if (DEBUGLEVEL >= 10) {
  99                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcCloseRaw, NDR_IN, r2);
 100                 }
 101                 dcesrv_EfsRpcCloseRaw(dce_call, mem_ctx, r2);
 102                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 103                         DEBUG(5,("function EfsRpcCloseRaw will reply async\n"));
 104                 }
 105                 break;
 106         }
 107         case 4: {
 108                 struct EfsRpcEncryptFileSrv *r2 = (struct EfsRpcEncryptFileSrv *)r;
 109                 if (DEBUGLEVEL >= 10) {
 110                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcEncryptFileSrv, NDR_IN, r2);
 111                 }
 112                 r2->out.result = dcesrv_EfsRpcEncryptFileSrv(dce_call, mem_ctx, r2);
 113                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 114                         DEBUG(5,("function EfsRpcEncryptFileSrv will reply async\n"));
 115                 }
 116                 break;
 117         }
 118         case 5: {
 119                 struct EfsRpcDecryptFileSrv *r2 = (struct EfsRpcDecryptFileSrv *)r;
 120                 if (DEBUGLEVEL >= 10) {
 121                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcDecryptFileSrv, NDR_IN, r2);
 122                 }
 123                 r2->out.result = dcesrv_EfsRpcDecryptFileSrv(dce_call, mem_ctx, r2);
 124                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 125                         DEBUG(5,("function EfsRpcDecryptFileSrv will reply async\n"));
 126                 }
 127                 break;
 128         }
 129         case 6: {
 130                 struct EfsRpcQueryUsersOnFile *r2 = (struct EfsRpcQueryUsersOnFile *)r;
 131                 if (DEBUGLEVEL >= 10) {
 132                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcQueryUsersOnFile, NDR_IN, r2);
 133                 }
 134                 r2->out.result = dcesrv_EfsRpcQueryUsersOnFile(dce_call, mem_ctx, r2);
 135                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 136                         DEBUG(5,("function EfsRpcQueryUsersOnFile will reply async\n"));
 137                 }
 138                 break;
 139         }
 140         case 7: {
 141                 struct EfsRpcQueryRecoveryAgents *r2 = (struct EfsRpcQueryRecoveryAgents *)r;
 142                 if (DEBUGLEVEL >= 10) {
 143                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcQueryRecoveryAgents, NDR_IN, r2);
 144                 }
 145                 r2->out.result = dcesrv_EfsRpcQueryRecoveryAgents(dce_call, mem_ctx, r2);
 146                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 147                         DEBUG(5,("function EfsRpcQueryRecoveryAgents will reply async\n"));
 148                 }
 149                 break;
 150         }
 151         case 8: {
 152                 struct EfsRpcRemoveUsersFromFile *r2 = (struct EfsRpcRemoveUsersFromFile *)r;
 153                 if (DEBUGLEVEL >= 10) {
 154                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcRemoveUsersFromFile, NDR_IN, r2);
 155                 }
 156                 r2->out.result = dcesrv_EfsRpcRemoveUsersFromFile(dce_call, mem_ctx, r2);
 157                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 158                         DEBUG(5,("function EfsRpcRemoveUsersFromFile will reply async\n"));
 159                 }
 160                 break;
 161         }
 162         case 9: {
 163                 struct EfsRpcAddUsersToFile *r2 = (struct EfsRpcAddUsersToFile *)r;
 164                 if (DEBUGLEVEL >= 10) {
 165                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcAddUsersToFile, NDR_IN, r2);
 166                 }
 167                 r2->out.result = dcesrv_EfsRpcAddUsersToFile(dce_call, mem_ctx, r2);
 168                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 169                         DEBUG(5,("function EfsRpcAddUsersToFile will reply async\n"));
 170                 }
 171                 break;
 172         }
 173         case 10: {
 174                 struct EfsRpcSetFileEncryptionKey *r2 = (struct EfsRpcSetFileEncryptionKey *)r;
 175                 if (DEBUGLEVEL >= 10) {
 176                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcSetFileEncryptionKey, NDR_IN, r2);
 177                 }
 178                 r2->out.result = dcesrv_EfsRpcSetFileEncryptionKey(dce_call, mem_ctx, r2);
 179                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 180                         DEBUG(5,("function EfsRpcSetFileEncryptionKey will reply async\n"));
 181                 }
 182                 break;
 183         }
 184         case 11: {
 185                 struct EfsRpcNotSupported *r2 = (struct EfsRpcNotSupported *)r;
 186                 if (DEBUGLEVEL >= 10) {
 187                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcNotSupported, NDR_IN, r2);
 188                 }
 189                 r2->out.result = dcesrv_EfsRpcNotSupported(dce_call, mem_ctx, r2);
 190                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 191                         DEBUG(5,("function EfsRpcNotSupported will reply async\n"));
 192                 }
 193                 break;
 194         }
 195         case 12: {
 196                 struct EfsRpcFileKeyInfo *r2 = (struct EfsRpcFileKeyInfo *)r;
 197                 if (DEBUGLEVEL >= 10) {
 198                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcFileKeyInfo, NDR_IN, r2);
 199                 }
 200                 r2->out.result = dcesrv_EfsRpcFileKeyInfo(dce_call, mem_ctx, r2);
 201                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 202                         DEBUG(5,("function EfsRpcFileKeyInfo will reply async\n"));
 203                 }
 204                 break;
 205         }
 206         case 13: {
 207                 struct EfsRpcDuplicateEncryptionInfoFile *r2 = (struct EfsRpcDuplicateEncryptionInfoFile *)r;
 208                 if (DEBUGLEVEL >= 10) {
 209                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcDuplicateEncryptionInfoFile, NDR_IN, r2);
 210                 }
 211                 r2->out.result = dcesrv_EfsRpcDuplicateEncryptionInfoFile(dce_call, mem_ctx, r2);
 212                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 213                         DEBUG(5,("function EfsRpcDuplicateEncryptionInfoFile will reply async\n"));
 214                 }
 215                 break;
 216         }
 217
 218         default:
 219                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 220                 break;
 221         }
 222
 223         if (dce_call->fault_code != 0) {
 224                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 225                           &ndr_table_efs, opnum, NDR_IN,
 226                                   &dce_call->pkt.u.request.stub_and_verifier);
 227                 return NT_STATUS_NET_WRITE_FAULT;
 228         }
 229
 230         return NT_STATUS_OK;
 231 }
 232
 233 static NTSTATUS efs__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 234 {
 235         uint16_t opnum = dce_call->pkt.u.request.opnum;
 236
 237         switch (opnum) {
 238         case 0: {
 239                 struct EfsRpcOpenFileRaw *r2 = (struct EfsRpcOpenFileRaw *)r;
 240                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 241                         DEBUG(5,("function EfsRpcOpenFileRaw replied async\n"));
 242                 }
 243                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 244                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcOpenFileRaw, NDR_OUT | NDR_SET_VALUES, r2);
 245                 }
 246                 if (dce_call->fault_code != 0) {
 247                         DEBUG(2,("dcerpc_fault %s in EfsRpcOpenFileRaw\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 248                 }
 249                 break;
 250         }
 251         case 1: {
 252                 struct EfsRpcReadFileRaw *r2 = (struct EfsRpcReadFileRaw *)r;
 253                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 254                         DEBUG(5,("function EfsRpcReadFileRaw replied async\n"));
 255                 }
 256                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 257                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcReadFileRaw, NDR_OUT | NDR_SET_VALUES, r2);
 258                 }
 259                 if (dce_call->fault_code != 0) {
 260                         DEBUG(2,("dcerpc_fault %s in EfsRpcReadFileRaw\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 261                 }
 262                 break;
 263         }
 264         case 2: {
 265                 struct EfsRpcWriteFileRaw *r2 = (struct EfsRpcWriteFileRaw *)r;
 266                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 267                         DEBUG(5,("function EfsRpcWriteFileRaw replied async\n"));
 268                 }
 269                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 270                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcWriteFileRaw, NDR_OUT | NDR_SET_VALUES, r2);
 271                 }
 272                 if (dce_call->fault_code != 0) {
 273                         DEBUG(2,("dcerpc_fault %s in EfsRpcWriteFileRaw\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 274                 }
 275                 break;
 276         }
 277         case 3: {
 278                 struct EfsRpcCloseRaw *r2 = (struct EfsRpcCloseRaw *)r;
 279                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 280                         DEBUG(5,("function EfsRpcCloseRaw replied async\n"));
 281                 }
 282                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 283                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcCloseRaw, NDR_OUT | NDR_SET_VALUES, r2);
 284                 }
 285                 if (dce_call->fault_code != 0) {
 286                         DEBUG(2,("dcerpc_fault %s in EfsRpcCloseRaw\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 287                 }
 288                 break;
 289         }
 290         case 4: {
 291                 struct EfsRpcEncryptFileSrv *r2 = (struct EfsRpcEncryptFileSrv *)r;
 292                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 293                         DEBUG(5,("function EfsRpcEncryptFileSrv replied async\n"));
 294                 }
 295                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 296                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcEncryptFileSrv, NDR_OUT | NDR_SET_VALUES, r2);
 297                 }
 298                 if (dce_call->fault_code != 0) {
 299                         DEBUG(2,("dcerpc_fault %s in EfsRpcEncryptFileSrv\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 300                 }
 301                 break;
 302         }
 303         case 5: {
 304                 struct EfsRpcDecryptFileSrv *r2 = (struct EfsRpcDecryptFileSrv *)r;
 305                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 306                         DEBUG(5,("function EfsRpcDecryptFileSrv replied async\n"));
 307                 }
 308                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 309                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcDecryptFileSrv, NDR_OUT | NDR_SET_VALUES, r2);
 310                 }
 311                 if (dce_call->fault_code != 0) {
 312                         DEBUG(2,("dcerpc_fault %s in EfsRpcDecryptFileSrv\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 313                 }
 314                 break;
 315         }
 316         case 6: {
 317                 struct EfsRpcQueryUsersOnFile *r2 = (struct EfsRpcQueryUsersOnFile *)r;
 318                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 319                         DEBUG(5,("function EfsRpcQueryUsersOnFile replied async\n"));
 320                 }
 321                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 322                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcQueryUsersOnFile, NDR_OUT | NDR_SET_VALUES, r2);
 323                 }
 324                 if (dce_call->fault_code != 0) {
 325                         DEBUG(2,("dcerpc_fault %s in EfsRpcQueryUsersOnFile\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 326                 }
 327                 break;
 328         }
 329         case 7: {
 330                 struct EfsRpcQueryRecoveryAgents *r2 = (struct EfsRpcQueryRecoveryAgents *)r;
 331                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 332                         DEBUG(5,("function EfsRpcQueryRecoveryAgents replied async\n"));
 333                 }
 334                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 335                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcQueryRecoveryAgents, NDR_OUT | NDR_SET_VALUES, r2);
 336                 }
 337                 if (dce_call->fault_code != 0) {
 338                         DEBUG(2,("dcerpc_fault %s in EfsRpcQueryRecoveryAgents\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 339                 }
 340                 break;
 341         }
 342         case 8: {
 343                 struct EfsRpcRemoveUsersFromFile *r2 = (struct EfsRpcRemoveUsersFromFile *)r;
 344                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 345                         DEBUG(5,("function EfsRpcRemoveUsersFromFile replied async\n"));
 346                 }
 347                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 348                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcRemoveUsersFromFile, NDR_OUT | NDR_SET_VALUES, r2);
 349                 }
 350                 if (dce_call->fault_code != 0) {
 351                         DEBUG(2,("dcerpc_fault %s in EfsRpcRemoveUsersFromFile\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 352                 }
 353                 break;
 354         }
 355         case 9: {
 356                 struct EfsRpcAddUsersToFile *r2 = (struct EfsRpcAddUsersToFile *)r;
 357                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 358                         DEBUG(5,("function EfsRpcAddUsersToFile replied async\n"));
 359                 }
 360                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 361                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcAddUsersToFile, NDR_OUT | NDR_SET_VALUES, r2);
 362                 }
 363                 if (dce_call->fault_code != 0) {
 364                         DEBUG(2,("dcerpc_fault %s in EfsRpcAddUsersToFile\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 365                 }
 366                 break;
 367         }
 368         case 10: {
 369                 struct EfsRpcSetFileEncryptionKey *r2 = (struct EfsRpcSetFileEncryptionKey *)r;
 370                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 371                         DEBUG(5,("function EfsRpcSetFileEncryptionKey replied async\n"));
 372                 }
 373                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 374                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcSetFileEncryptionKey, NDR_OUT | NDR_SET_VALUES, r2);
 375                 }
 376                 if (dce_call->fault_code != 0) {
 377                         DEBUG(2,("dcerpc_fault %s in EfsRpcSetFileEncryptionKey\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 378                 }
 379                 break;
 380         }
 381         case 11: {
 382                 struct EfsRpcNotSupported *r2 = (struct EfsRpcNotSupported *)r;
 383                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 384                         DEBUG(5,("function EfsRpcNotSupported replied async\n"));
 385                 }
 386                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 387                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcNotSupported, NDR_OUT | NDR_SET_VALUES, r2);
 388                 }
 389                 if (dce_call->fault_code != 0) {
 390                         DEBUG(2,("dcerpc_fault %s in EfsRpcNotSupported\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 391                 }
 392                 break;
 393         }
 394         case 12: {
 395                 struct EfsRpcFileKeyInfo *r2 = (struct EfsRpcFileKeyInfo *)r;
 396                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 397                         DEBUG(5,("function EfsRpcFileKeyInfo replied async\n"));
 398                 }
 399                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 400                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcFileKeyInfo, NDR_OUT | NDR_SET_VALUES, r2);
 401                 }
 402                 if (dce_call->fault_code != 0) {
 403                         DEBUG(2,("dcerpc_fault %s in EfsRpcFileKeyInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 404                 }
 405                 break;
 406         }
 407         case 13: {
 408                 struct EfsRpcDuplicateEncryptionInfoFile *r2 = (struct EfsRpcDuplicateEncryptionInfoFile *)r;
 409                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 410                         DEBUG(5,("function EfsRpcDuplicateEncryptionInfoFile replied async\n"));
 411                 }
 412                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 413                         NDR_PRINT_FUNCTION_DEBUG(EfsRpcDuplicateEncryptionInfoFile, NDR_OUT | NDR_SET_VALUES, r2);
 414                 }
 415                 if (dce_call->fault_code != 0) {
 416                         DEBUG(2,("dcerpc_fault %s in EfsRpcDuplicateEncryptionInfoFile\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 417                 }
 418                 break;
 419         }
 420
 421         default:
 422                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 423                 break;
 424         }
 425
 426         if (dce_call->fault_code != 0) {
 427                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 428                           &ndr_table_efs, opnum, NDR_IN,
 429                                   &dce_call->pkt.u.request.stub_and_verifier);
 430                 return NT_STATUS_NET_WRITE_FAULT;
 431         }
 432
 433         return NT_STATUS_OK;
 434 }
 435
 436 static NTSTATUS efs__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
 437 {
 438         enum ndr_err_code ndr_err;
 439         uint16_t opnum = dce_call->pkt.u.request.opnum;
 440
 441         ndr_err = ndr_table_efs.calls[opnum].ndr_push(push, NDR_OUT, r);
 442         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 443                 dce_call->fault_code = DCERPC_FAULT_NDR;
 444                 return NT_STATUS_NET_WRITE_FAULT;
 445         }
 446
 447         return NT_STATUS_OK;
 448 }
 449
 450 const struct dcesrv_interface dcesrv_efs_interface = {
 451         .name           = "efs",
 452         .syntax_id  = {{0xc681d488,0xd850,0x11d0,{0x8c,0x52},{0x00,0xc0,0x4f,0xd9,0x0f,0x7e}},1.0},
 453         .bind           = efs__op_bind,
 454         .unbind         = efs__op_unbind,
 455         .ndr_pull       = efs__op_ndr_pull,
 456         .dispatch       = efs__op_dispatch,
 457         .reply          = efs__op_reply,
 458         .ndr_push       = efs__op_ndr_push
 459 };
 460
 461
 462 static NTSTATUS efs__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
 463 {
 464         int i;
 465
 466         for (i=0;i<ndr_table_efs.endpoints->count;i++) {
 467                 NTSTATUS ret;
 468                 const char *name = ndr_table_efs.endpoints->names[i];
 469
 470                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_efs_interface, NULL);
 471                 if (!NT_STATUS_IS_OK(ret)) {
 472                         DEBUG(1,("efs_op_init_server: failed to register endpoint '%s'\n",name));
 473                         return ret;
 474                 }
 475         }
 476
 477         return NT_STATUS_OK;
 478 }
 479
 480 static bool efs__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
 481 {
 482         if (dcesrv_efs_interface.syntax_id.if_version == if_version &&
 483                 GUID_equal(&dcesrv_efs_interface.syntax_id.uuid, uuid)) {
 484                 memcpy(iface,&dcesrv_efs_interface, sizeof(*iface));
 485                 return true;
 486         }
 487
 488         return false;
 489 }
 490
 491 static bool efs__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
 492 {
 493         if (strcmp(dcesrv_efs_interface.name, name)==0) {
 494                 memcpy(iface, &dcesrv_efs_interface, sizeof(*iface));
 495                 return true;
 496         }
 497
 498         return false;
 499 }
 500
 501 NTSTATUS dcerpc_server_efs_init(void)
 502 {
 503         NTSTATUS ret;
 504         struct dcesrv_endpoint_server ep_server;
 505
 506         /* fill in our name */
 507         ep_server.name = "efs";
 508
 509         /* fill in all the operations */
 510         ep_server.init_server = efs__op_init_server;
 511
 512         ep_server.interface_by_uuid = efs__op_interface_by_uuid;
 513         ep_server.interface_by_name = efs__op_interface_by_name;
 514
 515         /* register ourselves with the DCERPC subsystem. */
 516         ret = dcerpc_register_ep_server(&ep_server);
 517
 518         if (!NT_STATUS_IS_OK(ret)) {
 519                 DEBUG(0,("Failed to register 'efs' endpoint server!\n"));
 520                 return ret;
 521         }
 522
 523         return ret;
 524 }
 525