bin.gen_ndr/default/librpc/gen_ndr/ndr_netlogon_s.c

   1 /* server functions auto-generated by pidl */
   2 #include "bin/default/librpc/gen_ndr/ndr_netlogon.h"
   3
   4 NTSTATUS dcerpc_server_netlogon_init(void);
   5
   6 /* netlogon - dcerpc server boilerplate generated by pidl */
   7
   8
   9 static NTSTATUS netlogon__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
  10 {
  11 #ifdef DCESRV_INTERFACE_NETLOGON_BIND
  12         return DCESRV_INTERFACE_NETLOGON_BIND(dce_call,iface);
  13 #else
  14         return NT_STATUS_OK;
  15 #endif
  16 }
  17
  18 static void netlogon__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
  19 {
  20 #ifdef DCESRV_INTERFACE_NETLOGON_UNBIND
  21         DCESRV_INTERFACE_NETLOGON_UNBIND(context, iface);
  22 #else
  23         return;
  24 #endif
  25 }
  26
  27 static NTSTATUS netlogon__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_netlogon.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_netlogon.calls[opnum].struct_size,
  41                           "struct %s",
  42                           ndr_table_netlogon.calls[opnum].name);
  43         NT_STATUS_HAVE_NO_MEMORY(*r);
  44
  45         /* unravel the NDR for the packet */
  46         ndr_err = ndr_table_netlogon.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_netlogon, 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 netlogon__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 netr_LogonUasLogon *r2 = (struct netr_LogonUasLogon *)r;
  65                 if (DEBUGLEVEL >= 10) {
  66                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonUasLogon, NDR_IN, r2);
  67                 }
  68                 r2->out.result = dcesrv_netr_LogonUasLogon(dce_call, mem_ctx, r2);
  69                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  70                         DEBUG(5,("function netr_LogonUasLogon will reply async\n"));
  71                 }
  72                 break;
  73         }
  74         case 1: {
  75                 struct netr_LogonUasLogoff *r2 = (struct netr_LogonUasLogoff *)r;
  76                 if (DEBUGLEVEL >= 10) {
  77                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonUasLogoff, NDR_IN, r2);
  78                 }
  79                 r2->out.result = dcesrv_netr_LogonUasLogoff(dce_call, mem_ctx, r2);
  80                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  81                         DEBUG(5,("function netr_LogonUasLogoff will reply async\n"));
  82                 }
  83                 break;
  84         }
  85         case 2: {
  86                 struct netr_LogonSamLogon *r2 = (struct netr_LogonSamLogon *)r;
  87                 if (DEBUGLEVEL >= 10) {
  88                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogon, NDR_IN, r2);
  89                 }
  90                 r2->out.result = dcesrv_netr_LogonSamLogon(dce_call, mem_ctx, r2);
  91                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
  92                         DEBUG(5,("function netr_LogonSamLogon will reply async\n"));
  93                 }
  94                 break;
  95         }
  96         case 3: {
  97                 struct netr_LogonSamLogoff *r2 = (struct netr_LogonSamLogoff *)r;
  98                 if (DEBUGLEVEL >= 10) {
  99                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogoff, NDR_IN, r2);
 100                 }
 101                 r2->out.result = dcesrv_netr_LogonSamLogoff(dce_call, mem_ctx, r2);
 102                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 103                         DEBUG(5,("function netr_LogonSamLogoff will reply async\n"));
 104                 }
 105                 break;
 106         }
 107         case 4: {
 108                 struct netr_ServerReqChallenge *r2 = (struct netr_ServerReqChallenge *)r;
 109                 if (DEBUGLEVEL >= 10) {
 110                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerReqChallenge, NDR_IN, r2);
 111                 }
 112                 r2->out.result = dcesrv_netr_ServerReqChallenge(dce_call, mem_ctx, r2);
 113                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 114                         DEBUG(5,("function netr_ServerReqChallenge will reply async\n"));
 115                 }
 116                 break;
 117         }
 118         case 5: {
 119                 struct netr_ServerAuthenticate *r2 = (struct netr_ServerAuthenticate *)r;
 120                 if (DEBUGLEVEL >= 10) {
 121                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate, NDR_IN, r2);
 122                 }
 123                 r2->out.result = dcesrv_netr_ServerAuthenticate(dce_call, mem_ctx, r2);
 124                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 125                         DEBUG(5,("function netr_ServerAuthenticate will reply async\n"));
 126                 }
 127                 break;
 128         }
 129         case 6: {
 130                 struct netr_ServerPasswordSet *r2 = (struct netr_ServerPasswordSet *)r;
 131                 if (DEBUGLEVEL >= 10) {
 132                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordSet, NDR_IN, r2);
 133                 }
 134                 r2->out.result = dcesrv_netr_ServerPasswordSet(dce_call, mem_ctx, r2);
 135                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 136                         DEBUG(5,("function netr_ServerPasswordSet will reply async\n"));
 137                 }
 138                 break;
 139         }
 140         case 7: {
 141                 struct netr_DatabaseDeltas *r2 = (struct netr_DatabaseDeltas *)r;
 142                 if (DEBUGLEVEL >= 10) {
 143                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseDeltas, NDR_IN, r2);
 144                 }
 145                 r2->out.result = dcesrv_netr_DatabaseDeltas(dce_call, mem_ctx, r2);
 146                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 147                         DEBUG(5,("function netr_DatabaseDeltas will reply async\n"));
 148                 }
 149                 break;
 150         }
 151         case 8: {
 152                 struct netr_DatabaseSync *r2 = (struct netr_DatabaseSync *)r;
 153                 if (DEBUGLEVEL >= 10) {
 154                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseSync, NDR_IN, r2);
 155                 }
 156                 r2->out.result = dcesrv_netr_DatabaseSync(dce_call, mem_ctx, r2);
 157                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 158                         DEBUG(5,("function netr_DatabaseSync will reply async\n"));
 159                 }
 160                 break;
 161         }
 162         case 9: {
 163                 struct netr_AccountDeltas *r2 = (struct netr_AccountDeltas *)r;
 164                 if (DEBUGLEVEL >= 10) {
 165                         NDR_PRINT_FUNCTION_DEBUG(netr_AccountDeltas, NDR_IN, r2);
 166                 }
 167                 r2->out.result = dcesrv_netr_AccountDeltas(dce_call, mem_ctx, r2);
 168                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 169                         DEBUG(5,("function netr_AccountDeltas will reply async\n"));
 170                 }
 171                 break;
 172         }
 173         case 10: {
 174                 struct netr_AccountSync *r2 = (struct netr_AccountSync *)r;
 175                 if (DEBUGLEVEL >= 10) {
 176                         NDR_PRINT_FUNCTION_DEBUG(netr_AccountSync, NDR_IN, r2);
 177                 }
 178                 r2->out.result = dcesrv_netr_AccountSync(dce_call, mem_ctx, r2);
 179                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 180                         DEBUG(5,("function netr_AccountSync will reply async\n"));
 181                 }
 182                 break;
 183         }
 184         case 11: {
 185                 struct netr_GetDcName *r2 = (struct netr_GetDcName *)r;
 186                 if (DEBUGLEVEL >= 10) {
 187                         NDR_PRINT_FUNCTION_DEBUG(netr_GetDcName, NDR_IN, r2);
 188                 }
 189                 r2->out.result = dcesrv_netr_GetDcName(dce_call, mem_ctx, r2);
 190                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 191                         DEBUG(5,("function netr_GetDcName will reply async\n"));
 192                 }
 193                 break;
 194         }
 195         case 12: {
 196                 struct netr_LogonControl *r2 = (struct netr_LogonControl *)r;
 197                 if (DEBUGLEVEL >= 10) {
 198                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl, NDR_IN, r2);
 199                 }
 200                 r2->out.result = dcesrv_netr_LogonControl(dce_call, mem_ctx, r2);
 201                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 202                         DEBUG(5,("function netr_LogonControl will reply async\n"));
 203                 }
 204                 break;
 205         }
 206         case 13: {
 207                 struct netr_GetAnyDCName *r2 = (struct netr_GetAnyDCName *)r;
 208                 if (DEBUGLEVEL >= 10) {
 209                         NDR_PRINT_FUNCTION_DEBUG(netr_GetAnyDCName, NDR_IN, r2);
 210                 }
 211                 r2->out.result = dcesrv_netr_GetAnyDCName(dce_call, mem_ctx, r2);
 212                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 213                         DEBUG(5,("function netr_GetAnyDCName will reply async\n"));
 214                 }
 215                 break;
 216         }
 217         case 14: {
 218                 struct netr_LogonControl2 *r2 = (struct netr_LogonControl2 *)r;
 219                 if (DEBUGLEVEL >= 10) {
 220                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl2, NDR_IN, r2);
 221                 }
 222                 r2->out.result = dcesrv_netr_LogonControl2(dce_call, mem_ctx, r2);
 223                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 224                         DEBUG(5,("function netr_LogonControl2 will reply async\n"));
 225                 }
 226                 break;
 227         }
 228         case 15: {
 229                 struct netr_ServerAuthenticate2 *r2 = (struct netr_ServerAuthenticate2 *)r;
 230                 if (DEBUGLEVEL >= 10) {
 231                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate2, NDR_IN, r2);
 232                 }
 233                 r2->out.result = dcesrv_netr_ServerAuthenticate2(dce_call, mem_ctx, r2);
 234                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 235                         DEBUG(5,("function netr_ServerAuthenticate2 will reply async\n"));
 236                 }
 237                 break;
 238         }
 239         case 16: {
 240                 struct netr_DatabaseSync2 *r2 = (struct netr_DatabaseSync2 *)r;
 241                 if (DEBUGLEVEL >= 10) {
 242                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseSync2, NDR_IN, r2);
 243                 }
 244                 r2->out.result = dcesrv_netr_DatabaseSync2(dce_call, mem_ctx, r2);
 245                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 246                         DEBUG(5,("function netr_DatabaseSync2 will reply async\n"));
 247                 }
 248                 break;
 249         }
 250         case 17: {
 251                 struct netr_DatabaseRedo *r2 = (struct netr_DatabaseRedo *)r;
 252                 if (DEBUGLEVEL >= 10) {
 253                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseRedo, NDR_IN, r2);
 254                 }
 255                 r2->out.result = dcesrv_netr_DatabaseRedo(dce_call, mem_ctx, r2);
 256                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 257                         DEBUG(5,("function netr_DatabaseRedo will reply async\n"));
 258                 }
 259                 break;
 260         }
 261         case 18: {
 262                 struct netr_LogonControl2Ex *r2 = (struct netr_LogonControl2Ex *)r;
 263                 if (DEBUGLEVEL >= 10) {
 264                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl2Ex, NDR_IN, r2);
 265                 }
 266                 r2->out.result = dcesrv_netr_LogonControl2Ex(dce_call, mem_ctx, r2);
 267                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 268                         DEBUG(5,("function netr_LogonControl2Ex will reply async\n"));
 269                 }
 270                 break;
 271         }
 272         case 19: {
 273                 struct netr_NetrEnumerateTrustedDomains *r2 = (struct netr_NetrEnumerateTrustedDomains *)r;
 274                 if (DEBUGLEVEL >= 10) {
 275                         NDR_PRINT_FUNCTION_DEBUG(netr_NetrEnumerateTrustedDomains, NDR_IN, r2);
 276                 }
 277                 r2->out.result = dcesrv_netr_NetrEnumerateTrustedDomains(dce_call, mem_ctx, r2);
 278                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 279                         DEBUG(5,("function netr_NetrEnumerateTrustedDomains will reply async\n"));
 280                 }
 281                 break;
 282         }
 283         case 20: {
 284                 struct netr_DsRGetDCName *r2 = (struct netr_DsRGetDCName *)r;
 285                 if (DEBUGLEVEL >= 10) {
 286                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCName, NDR_IN, r2);
 287                 }
 288                 r2->out.result = dcesrv_netr_DsRGetDCName(dce_call, mem_ctx, r2);
 289                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 290                         DEBUG(5,("function netr_DsRGetDCName will reply async\n"));
 291                 }
 292                 break;
 293         }
 294         case 21: {
 295                 struct netr_LogonGetCapabilities *r2 = (struct netr_LogonGetCapabilities *)r;
 296                 if (DEBUGLEVEL >= 10) {
 297                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetCapabilities, NDR_IN, r2);
 298                 }
 299                 r2->out.result = dcesrv_netr_LogonGetCapabilities(dce_call, mem_ctx, r2);
 300                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 301                         DEBUG(5,("function netr_LogonGetCapabilities will reply async\n"));
 302                 }
 303                 break;
 304         }
 305         case 22: {
 306                 struct netr_NETRLOGONSETSERVICEBITS *r2 = (struct netr_NETRLOGONSETSERVICEBITS *)r;
 307                 if (DEBUGLEVEL >= 10) {
 308                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONSETSERVICEBITS, NDR_IN, r2);
 309                 }
 310                 r2->out.result = dcesrv_netr_NETRLOGONSETSERVICEBITS(dce_call, mem_ctx, r2);
 311                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 312                         DEBUG(5,("function netr_NETRLOGONSETSERVICEBITS will reply async\n"));
 313                 }
 314                 break;
 315         }
 316         case 23: {
 317                 struct netr_LogonGetTrustRid *r2 = (struct netr_LogonGetTrustRid *)r;
 318                 if (DEBUGLEVEL >= 10) {
 319                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetTrustRid, NDR_IN, r2);
 320                 }
 321                 r2->out.result = dcesrv_netr_LogonGetTrustRid(dce_call, mem_ctx, r2);
 322                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 323                         DEBUG(5,("function netr_LogonGetTrustRid will reply async\n"));
 324                 }
 325                 break;
 326         }
 327         case 24: {
 328                 struct netr_NETRLOGONCOMPUTESERVERDIGEST *r2 = (struct netr_NETRLOGONCOMPUTESERVERDIGEST *)r;
 329                 if (DEBUGLEVEL >= 10) {
 330                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, NDR_IN, r2);
 331                 }
 332                 r2->out.result = dcesrv_netr_NETRLOGONCOMPUTESERVERDIGEST(dce_call, mem_ctx, r2);
 333                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 334                         DEBUG(5,("function netr_NETRLOGONCOMPUTESERVERDIGEST will reply async\n"));
 335                 }
 336                 break;
 337         }
 338         case 25: {
 339                 struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r2 = (struct netr_NETRLOGONCOMPUTECLIENTDIGEST *)r;
 340                 if (DEBUGLEVEL >= 10) {
 341                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, NDR_IN, r2);
 342                 }
 343                 r2->out.result = dcesrv_netr_NETRLOGONCOMPUTECLIENTDIGEST(dce_call, mem_ctx, r2);
 344                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 345                         DEBUG(5,("function netr_NETRLOGONCOMPUTECLIENTDIGEST will reply async\n"));
 346                 }
 347                 break;
 348         }
 349         case 26: {
 350                 struct netr_ServerAuthenticate3 *r2 = (struct netr_ServerAuthenticate3 *)r;
 351                 if (DEBUGLEVEL >= 10) {
 352                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate3, NDR_IN, r2);
 353                 }
 354                 r2->out.result = dcesrv_netr_ServerAuthenticate3(dce_call, mem_ctx, r2);
 355                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 356                         DEBUG(5,("function netr_ServerAuthenticate3 will reply async\n"));
 357                 }
 358                 break;
 359         }
 360         case 27: {
 361                 struct netr_DsRGetDCNameEx *r2 = (struct netr_DsRGetDCNameEx *)r;
 362                 if (DEBUGLEVEL >= 10) {
 363                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCNameEx, NDR_IN, r2);
 364                 }
 365                 r2->out.result = dcesrv_netr_DsRGetDCNameEx(dce_call, mem_ctx, r2);
 366                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 367                         DEBUG(5,("function netr_DsRGetDCNameEx will reply async\n"));
 368                 }
 369                 break;
 370         }
 371         case 28: {
 372                 struct netr_DsRGetSiteName *r2 = (struct netr_DsRGetSiteName *)r;
 373                 if (DEBUGLEVEL >= 10) {
 374                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetSiteName, NDR_IN, r2);
 375                 }
 376                 r2->out.result = dcesrv_netr_DsRGetSiteName(dce_call, mem_ctx, r2);
 377                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 378                         DEBUG(5,("function netr_DsRGetSiteName will reply async\n"));
 379                 }
 380                 break;
 381         }
 382         case 29: {
 383                 struct netr_LogonGetDomainInfo *r2 = (struct netr_LogonGetDomainInfo *)r;
 384                 if (DEBUGLEVEL >= 10) {
 385                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetDomainInfo, NDR_IN, r2);
 386                 }
 387                 r2->out.result = dcesrv_netr_LogonGetDomainInfo(dce_call, mem_ctx, r2);
 388                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 389                         DEBUG(5,("function netr_LogonGetDomainInfo will reply async\n"));
 390                 }
 391                 break;
 392         }
 393         case 30: {
 394                 struct netr_ServerPasswordSet2 *r2 = (struct netr_ServerPasswordSet2 *)r;
 395                 if (DEBUGLEVEL >= 10) {
 396                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordSet2, NDR_IN, r2);
 397                 }
 398                 r2->out.result = dcesrv_netr_ServerPasswordSet2(dce_call, mem_ctx, r2);
 399                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 400                         DEBUG(5,("function netr_ServerPasswordSet2 will reply async\n"));
 401                 }
 402                 break;
 403         }
 404         case 31: {
 405                 struct netr_ServerPasswordGet *r2 = (struct netr_ServerPasswordGet *)r;
 406                 if (DEBUGLEVEL >= 10) {
 407                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordGet, NDR_IN, r2);
 408                 }
 409                 r2->out.result = dcesrv_netr_ServerPasswordGet(dce_call, mem_ctx, r2);
 410                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 411                         DEBUG(5,("function netr_ServerPasswordGet will reply async\n"));
 412                 }
 413                 break;
 414         }
 415         case 32: {
 416                 struct netr_NETRLOGONSENDTOSAM *r2 = (struct netr_NETRLOGONSENDTOSAM *)r;
 417                 if (DEBUGLEVEL >= 10) {
 418                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONSENDTOSAM, NDR_IN, r2);
 419                 }
 420                 r2->out.result = dcesrv_netr_NETRLOGONSENDTOSAM(dce_call, mem_ctx, r2);
 421                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 422                         DEBUG(5,("function netr_NETRLOGONSENDTOSAM will reply async\n"));
 423                 }
 424                 break;
 425         }
 426         case 33: {
 427                 struct netr_DsRAddressToSitenamesW *r2 = (struct netr_DsRAddressToSitenamesW *)r;
 428                 if (DEBUGLEVEL >= 10) {
 429                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRAddressToSitenamesW, NDR_IN, r2);
 430                 }
 431                 r2->out.result = dcesrv_netr_DsRAddressToSitenamesW(dce_call, mem_ctx, r2);
 432                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 433                         DEBUG(5,("function netr_DsRAddressToSitenamesW will reply async\n"));
 434                 }
 435                 break;
 436         }
 437         case 34: {
 438                 struct netr_DsRGetDCNameEx2 *r2 = (struct netr_DsRGetDCNameEx2 *)r;
 439                 if (DEBUGLEVEL >= 10) {
 440                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCNameEx2, NDR_IN, r2);
 441                 }
 442                 r2->out.result = dcesrv_netr_DsRGetDCNameEx2(dce_call, mem_ctx, r2);
 443                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 444                         DEBUG(5,("function netr_DsRGetDCNameEx2 will reply async\n"));
 445                 }
 446                 break;
 447         }
 448         case 35: {
 449                 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r2 = (struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *)r;
 450                 if (DEBUGLEVEL >= 10) {
 451                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, NDR_IN, r2);
 452                 }
 453                 r2->out.result = dcesrv_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(dce_call, mem_ctx, r2);
 454                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 455                         DEBUG(5,("function netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN will reply async\n"));
 456                 }
 457                 break;
 458         }
 459         case 36: {
 460                 struct netr_NetrEnumerateTrustedDomainsEx *r2 = (struct netr_NetrEnumerateTrustedDomainsEx *)r;
 461                 if (DEBUGLEVEL >= 10) {
 462                         NDR_PRINT_FUNCTION_DEBUG(netr_NetrEnumerateTrustedDomainsEx, NDR_IN, r2);
 463                 }
 464                 r2->out.result = dcesrv_netr_NetrEnumerateTrustedDomainsEx(dce_call, mem_ctx, r2);
 465                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 466                         DEBUG(5,("function netr_NetrEnumerateTrustedDomainsEx will reply async\n"));
 467                 }
 468                 break;
 469         }
 470         case 37: {
 471                 struct netr_DsRAddressToSitenamesExW *r2 = (struct netr_DsRAddressToSitenamesExW *)r;
 472                 if (DEBUGLEVEL >= 10) {
 473                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRAddressToSitenamesExW, NDR_IN, r2);
 474                 }
 475                 r2->out.result = dcesrv_netr_DsRAddressToSitenamesExW(dce_call, mem_ctx, r2);
 476                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 477                         DEBUG(5,("function netr_DsRAddressToSitenamesExW will reply async\n"));
 478                 }
 479                 break;
 480         }
 481         case 38: {
 482                 struct netr_DsrGetDcSiteCoverageW *r2 = (struct netr_DsrGetDcSiteCoverageW *)r;
 483                 if (DEBUGLEVEL >= 10) {
 484                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrGetDcSiteCoverageW, NDR_IN, r2);
 485                 }
 486                 r2->out.result = dcesrv_netr_DsrGetDcSiteCoverageW(dce_call, mem_ctx, r2);
 487                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 488                         DEBUG(5,("function netr_DsrGetDcSiteCoverageW will reply async\n"));
 489                 }
 490                 break;
 491         }
 492         case 39: {
 493                 struct netr_LogonSamLogonEx *r2 = (struct netr_LogonSamLogonEx *)r;
 494                 if (DEBUGLEVEL >= 10) {
 495                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogonEx, NDR_IN, r2);
 496                 }
 497                 r2->out.result = dcesrv_netr_LogonSamLogonEx(dce_call, mem_ctx, r2);
 498                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 499                         DEBUG(5,("function netr_LogonSamLogonEx will reply async\n"));
 500                 }
 501                 break;
 502         }
 503         case 40: {
 504                 struct netr_DsrEnumerateDomainTrusts *r2 = (struct netr_DsrEnumerateDomainTrusts *)r;
 505                 if (DEBUGLEVEL >= 10) {
 506                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrEnumerateDomainTrusts, NDR_IN, r2);
 507                 }
 508                 r2->out.result = dcesrv_netr_DsrEnumerateDomainTrusts(dce_call, mem_ctx, r2);
 509                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 510                         DEBUG(5,("function netr_DsrEnumerateDomainTrusts will reply async\n"));
 511                 }
 512                 break;
 513         }
 514         case 41: {
 515                 struct netr_DsrDeregisterDNSHostRecords *r2 = (struct netr_DsrDeregisterDNSHostRecords *)r;
 516                 if (DEBUGLEVEL >= 10) {
 517                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrDeregisterDNSHostRecords, NDR_IN, r2);
 518                 }
 519                 r2->out.result = dcesrv_netr_DsrDeregisterDNSHostRecords(dce_call, mem_ctx, r2);
 520                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 521                         DEBUG(5,("function netr_DsrDeregisterDNSHostRecords will reply async\n"));
 522                 }
 523                 break;
 524         }
 525         case 42: {
 526                 struct netr_ServerTrustPasswordsGet *r2 = (struct netr_ServerTrustPasswordsGet *)r;
 527                 if (DEBUGLEVEL >= 10) {
 528                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerTrustPasswordsGet, NDR_IN, r2);
 529                 }
 530                 r2->out.result = dcesrv_netr_ServerTrustPasswordsGet(dce_call, mem_ctx, r2);
 531                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 532                         DEBUG(5,("function netr_ServerTrustPasswordsGet will reply async\n"));
 533                 }
 534                 break;
 535         }
 536         case 43: {
 537                 struct netr_DsRGetForestTrustInformation *r2 = (struct netr_DsRGetForestTrustInformation *)r;
 538                 if (DEBUGLEVEL >= 10) {
 539                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetForestTrustInformation, NDR_IN, r2);
 540                 }
 541                 r2->out.result = dcesrv_netr_DsRGetForestTrustInformation(dce_call, mem_ctx, r2);
 542                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 543                         DEBUG(5,("function netr_DsRGetForestTrustInformation will reply async\n"));
 544                 }
 545                 break;
 546         }
 547         case 44: {
 548                 struct netr_GetForestTrustInformation *r2 = (struct netr_GetForestTrustInformation *)r;
 549                 if (DEBUGLEVEL >= 10) {
 550                         NDR_PRINT_FUNCTION_DEBUG(netr_GetForestTrustInformation, NDR_IN, r2);
 551                 }
 552                 r2->out.result = dcesrv_netr_GetForestTrustInformation(dce_call, mem_ctx, r2);
 553                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 554                         DEBUG(5,("function netr_GetForestTrustInformation will reply async\n"));
 555                 }
 556                 break;
 557         }
 558         case 45: {
 559                 struct netr_LogonSamLogonWithFlags *r2 = (struct netr_LogonSamLogonWithFlags *)r;
 560                 if (DEBUGLEVEL >= 10) {
 561                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogonWithFlags, NDR_IN, r2);
 562                 }
 563                 r2->out.result = dcesrv_netr_LogonSamLogonWithFlags(dce_call, mem_ctx, r2);
 564                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 565                         DEBUG(5,("function netr_LogonSamLogonWithFlags will reply async\n"));
 566                 }
 567                 break;
 568         }
 569         case 46: {
 570                 struct netr_ServerGetTrustInfo *r2 = (struct netr_ServerGetTrustInfo *)r;
 571                 if (DEBUGLEVEL >= 10) {
 572                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerGetTrustInfo, NDR_IN, r2);
 573                 }
 574                 r2->out.result = dcesrv_netr_ServerGetTrustInfo(dce_call, mem_ctx, r2);
 575                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 576                         DEBUG(5,("function netr_ServerGetTrustInfo will reply async\n"));
 577                 }
 578                 break;
 579         }
 580         case 47: {
 581                 struct netr_Unused47 *r2 = (struct netr_Unused47 *)r;
 582                 if (DEBUGLEVEL >= 10) {
 583                         NDR_PRINT_FUNCTION_DEBUG(netr_Unused47, NDR_IN, r2);
 584                 }
 585                 r2->out.result = dcesrv_netr_Unused47(dce_call, mem_ctx, r2);
 586                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 587                         DEBUG(5,("function netr_Unused47 will reply async\n"));
 588                 }
 589                 break;
 590         }
 591         case 48: {
 592                 struct netr_DsrUpdateReadOnlyServerDnsRecords *r2 = (struct netr_DsrUpdateReadOnlyServerDnsRecords *)r;
 593                 if (DEBUGLEVEL >= 10) {
 594                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrUpdateReadOnlyServerDnsRecords, NDR_IN, r2);
 595                 }
 596                 r2->out.result = dcesrv_netr_DsrUpdateReadOnlyServerDnsRecords(dce_call, mem_ctx, r2);
 597                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 598                         DEBUG(5,("function netr_DsrUpdateReadOnlyServerDnsRecords will reply async\n"));
 599                 }
 600                 break;
 601         }
 602
 603         default:
 604                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
 605                 break;
 606         }
 607
 608         if (dce_call->fault_code != 0) {
 609                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
 610                           &ndr_table_netlogon, opnum, NDR_IN,
 611                                   &dce_call->pkt.u.request.stub_and_verifier);
 612                 return NT_STATUS_NET_WRITE_FAULT;
 613         }
 614
 615         return NT_STATUS_OK;
 616 }
 617
 618 static NTSTATUS netlogon__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
 619 {
 620         uint16_t opnum = dce_call->pkt.u.request.opnum;
 621
 622         switch (opnum) {
 623         case 0: {
 624                 struct netr_LogonUasLogon *r2 = (struct netr_LogonUasLogon *)r;
 625                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 626                         DEBUG(5,("function netr_LogonUasLogon replied async\n"));
 627                 }
 628                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 629                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonUasLogon, NDR_OUT | NDR_SET_VALUES, r2);
 630                 }
 631                 if (dce_call->fault_code != 0) {
 632                         DEBUG(2,("dcerpc_fault %s in netr_LogonUasLogon\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 633                 }
 634                 break;
 635         }
 636         case 1: {
 637                 struct netr_LogonUasLogoff *r2 = (struct netr_LogonUasLogoff *)r;
 638                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 639                         DEBUG(5,("function netr_LogonUasLogoff replied async\n"));
 640                 }
 641                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 642                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonUasLogoff, NDR_OUT | NDR_SET_VALUES, r2);
 643                 }
 644                 if (dce_call->fault_code != 0) {
 645                         DEBUG(2,("dcerpc_fault %s in netr_LogonUasLogoff\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 646                 }
 647                 break;
 648         }
 649         case 2: {
 650                 struct netr_LogonSamLogon *r2 = (struct netr_LogonSamLogon *)r;
 651                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 652                         DEBUG(5,("function netr_LogonSamLogon replied async\n"));
 653                 }
 654                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 655                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogon, NDR_OUT | NDR_SET_VALUES, r2);
 656                 }
 657                 if (dce_call->fault_code != 0) {
 658                         DEBUG(2,("dcerpc_fault %s in netr_LogonSamLogon\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 659                 }
 660                 break;
 661         }
 662         case 3: {
 663                 struct netr_LogonSamLogoff *r2 = (struct netr_LogonSamLogoff *)r;
 664                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 665                         DEBUG(5,("function netr_LogonSamLogoff replied async\n"));
 666                 }
 667                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 668                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogoff, NDR_OUT | NDR_SET_VALUES, r2);
 669                 }
 670                 if (dce_call->fault_code != 0) {
 671                         DEBUG(2,("dcerpc_fault %s in netr_LogonSamLogoff\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 672                 }
 673                 break;
 674         }
 675         case 4: {
 676                 struct netr_ServerReqChallenge *r2 = (struct netr_ServerReqChallenge *)r;
 677                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 678                         DEBUG(5,("function netr_ServerReqChallenge replied async\n"));
 679                 }
 680                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 681                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerReqChallenge, NDR_OUT | NDR_SET_VALUES, r2);
 682                 }
 683                 if (dce_call->fault_code != 0) {
 684                         DEBUG(2,("dcerpc_fault %s in netr_ServerReqChallenge\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 685                 }
 686                 break;
 687         }
 688         case 5: {
 689                 struct netr_ServerAuthenticate *r2 = (struct netr_ServerAuthenticate *)r;
 690                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 691                         DEBUG(5,("function netr_ServerAuthenticate replied async\n"));
 692                 }
 693                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 694                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate, NDR_OUT | NDR_SET_VALUES, r2);
 695                 }
 696                 if (dce_call->fault_code != 0) {
 697                         DEBUG(2,("dcerpc_fault %s in netr_ServerAuthenticate\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 698                 }
 699                 break;
 700         }
 701         case 6: {
 702                 struct netr_ServerPasswordSet *r2 = (struct netr_ServerPasswordSet *)r;
 703                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 704                         DEBUG(5,("function netr_ServerPasswordSet replied async\n"));
 705                 }
 706                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 707                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordSet, NDR_OUT | NDR_SET_VALUES, r2);
 708                 }
 709                 if (dce_call->fault_code != 0) {
 710                         DEBUG(2,("dcerpc_fault %s in netr_ServerPasswordSet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 711                 }
 712                 break;
 713         }
 714         case 7: {
 715                 struct netr_DatabaseDeltas *r2 = (struct netr_DatabaseDeltas *)r;
 716                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 717                         DEBUG(5,("function netr_DatabaseDeltas replied async\n"));
 718                 }
 719                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 720                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseDeltas, NDR_OUT | NDR_SET_VALUES, r2);
 721                 }
 722                 if (dce_call->fault_code != 0) {
 723                         DEBUG(2,("dcerpc_fault %s in netr_DatabaseDeltas\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 724                 }
 725                 break;
 726         }
 727         case 8: {
 728                 struct netr_DatabaseSync *r2 = (struct netr_DatabaseSync *)r;
 729                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 730                         DEBUG(5,("function netr_DatabaseSync replied async\n"));
 731                 }
 732                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 733                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseSync, NDR_OUT | NDR_SET_VALUES, r2);
 734                 }
 735                 if (dce_call->fault_code != 0) {
 736                         DEBUG(2,("dcerpc_fault %s in netr_DatabaseSync\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 737                 }
 738                 break;
 739         }
 740         case 9: {
 741                 struct netr_AccountDeltas *r2 = (struct netr_AccountDeltas *)r;
 742                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 743                         DEBUG(5,("function netr_AccountDeltas replied async\n"));
 744                 }
 745                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 746                         NDR_PRINT_FUNCTION_DEBUG(netr_AccountDeltas, NDR_OUT | NDR_SET_VALUES, r2);
 747                 }
 748                 if (dce_call->fault_code != 0) {
 749                         DEBUG(2,("dcerpc_fault %s in netr_AccountDeltas\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 750                 }
 751                 break;
 752         }
 753         case 10: {
 754                 struct netr_AccountSync *r2 = (struct netr_AccountSync *)r;
 755                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 756                         DEBUG(5,("function netr_AccountSync replied async\n"));
 757                 }
 758                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 759                         NDR_PRINT_FUNCTION_DEBUG(netr_AccountSync, NDR_OUT | NDR_SET_VALUES, r2);
 760                 }
 761                 if (dce_call->fault_code != 0) {
 762                         DEBUG(2,("dcerpc_fault %s in netr_AccountSync\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 763                 }
 764                 break;
 765         }
 766         case 11: {
 767                 struct netr_GetDcName *r2 = (struct netr_GetDcName *)r;
 768                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 769                         DEBUG(5,("function netr_GetDcName replied async\n"));
 770                 }
 771                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 772                         NDR_PRINT_FUNCTION_DEBUG(netr_GetDcName, NDR_OUT | NDR_SET_VALUES, r2);
 773                 }
 774                 if (dce_call->fault_code != 0) {
 775                         DEBUG(2,("dcerpc_fault %s in netr_GetDcName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 776                 }
 777                 break;
 778         }
 779         case 12: {
 780                 struct netr_LogonControl *r2 = (struct netr_LogonControl *)r;
 781                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 782                         DEBUG(5,("function netr_LogonControl replied async\n"));
 783                 }
 784                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 785                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl, NDR_OUT | NDR_SET_VALUES, r2);
 786                 }
 787                 if (dce_call->fault_code != 0) {
 788                         DEBUG(2,("dcerpc_fault %s in netr_LogonControl\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 789                 }
 790                 break;
 791         }
 792         case 13: {
 793                 struct netr_GetAnyDCName *r2 = (struct netr_GetAnyDCName *)r;
 794                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 795                         DEBUG(5,("function netr_GetAnyDCName replied async\n"));
 796                 }
 797                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 798                         NDR_PRINT_FUNCTION_DEBUG(netr_GetAnyDCName, NDR_OUT | NDR_SET_VALUES, r2);
 799                 }
 800                 if (dce_call->fault_code != 0) {
 801                         DEBUG(2,("dcerpc_fault %s in netr_GetAnyDCName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 802                 }
 803                 break;
 804         }
 805         case 14: {
 806                 struct netr_LogonControl2 *r2 = (struct netr_LogonControl2 *)r;
 807                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 808                         DEBUG(5,("function netr_LogonControl2 replied async\n"));
 809                 }
 810                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 811                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl2, NDR_OUT | NDR_SET_VALUES, r2);
 812                 }
 813                 if (dce_call->fault_code != 0) {
 814                         DEBUG(2,("dcerpc_fault %s in netr_LogonControl2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 815                 }
 816                 break;
 817         }
 818         case 15: {
 819                 struct netr_ServerAuthenticate2 *r2 = (struct netr_ServerAuthenticate2 *)r;
 820                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 821                         DEBUG(5,("function netr_ServerAuthenticate2 replied async\n"));
 822                 }
 823                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 824                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate2, NDR_OUT | NDR_SET_VALUES, r2);
 825                 }
 826                 if (dce_call->fault_code != 0) {
 827                         DEBUG(2,("dcerpc_fault %s in netr_ServerAuthenticate2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 828                 }
 829                 break;
 830         }
 831         case 16: {
 832                 struct netr_DatabaseSync2 *r2 = (struct netr_DatabaseSync2 *)r;
 833                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 834                         DEBUG(5,("function netr_DatabaseSync2 replied async\n"));
 835                 }
 836                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 837                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseSync2, NDR_OUT | NDR_SET_VALUES, r2);
 838                 }
 839                 if (dce_call->fault_code != 0) {
 840                         DEBUG(2,("dcerpc_fault %s in netr_DatabaseSync2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 841                 }
 842                 break;
 843         }
 844         case 17: {
 845                 struct netr_DatabaseRedo *r2 = (struct netr_DatabaseRedo *)r;
 846                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 847                         DEBUG(5,("function netr_DatabaseRedo replied async\n"));
 848                 }
 849                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 850                         NDR_PRINT_FUNCTION_DEBUG(netr_DatabaseRedo, NDR_OUT | NDR_SET_VALUES, r2);
 851                 }
 852                 if (dce_call->fault_code != 0) {
 853                         DEBUG(2,("dcerpc_fault %s in netr_DatabaseRedo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 854                 }
 855                 break;
 856         }
 857         case 18: {
 858                 struct netr_LogonControl2Ex *r2 = (struct netr_LogonControl2Ex *)r;
 859                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 860                         DEBUG(5,("function netr_LogonControl2Ex replied async\n"));
 861                 }
 862                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 863                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonControl2Ex, NDR_OUT | NDR_SET_VALUES, r2);
 864                 }
 865                 if (dce_call->fault_code != 0) {
 866                         DEBUG(2,("dcerpc_fault %s in netr_LogonControl2Ex\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 867                 }
 868                 break;
 869         }
 870         case 19: {
 871                 struct netr_NetrEnumerateTrustedDomains *r2 = (struct netr_NetrEnumerateTrustedDomains *)r;
 872                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 873                         DEBUG(5,("function netr_NetrEnumerateTrustedDomains replied async\n"));
 874                 }
 875                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 876                         NDR_PRINT_FUNCTION_DEBUG(netr_NetrEnumerateTrustedDomains, NDR_OUT | NDR_SET_VALUES, r2);
 877                 }
 878                 if (dce_call->fault_code != 0) {
 879                         DEBUG(2,("dcerpc_fault %s in netr_NetrEnumerateTrustedDomains\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 880                 }
 881                 break;
 882         }
 883         case 20: {
 884                 struct netr_DsRGetDCName *r2 = (struct netr_DsRGetDCName *)r;
 885                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 886                         DEBUG(5,("function netr_DsRGetDCName replied async\n"));
 887                 }
 888                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 889                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCName, NDR_OUT | NDR_SET_VALUES, r2);
 890                 }
 891                 if (dce_call->fault_code != 0) {
 892                         DEBUG(2,("dcerpc_fault %s in netr_DsRGetDCName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 893                 }
 894                 break;
 895         }
 896         case 21: {
 897                 struct netr_LogonGetCapabilities *r2 = (struct netr_LogonGetCapabilities *)r;
 898                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 899                         DEBUG(5,("function netr_LogonGetCapabilities replied async\n"));
 900                 }
 901                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 902                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetCapabilities, NDR_OUT | NDR_SET_VALUES, r2);
 903                 }
 904                 if (dce_call->fault_code != 0) {
 905                         DEBUG(2,("dcerpc_fault %s in netr_LogonGetCapabilities\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 906                 }
 907                 break;
 908         }
 909         case 22: {
 910                 struct netr_NETRLOGONSETSERVICEBITS *r2 = (struct netr_NETRLOGONSETSERVICEBITS *)r;
 911                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 912                         DEBUG(5,("function netr_NETRLOGONSETSERVICEBITS replied async\n"));
 913                 }
 914                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 915                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONSETSERVICEBITS, NDR_OUT | NDR_SET_VALUES, r2);
 916                 }
 917                 if (dce_call->fault_code != 0) {
 918                         DEBUG(2,("dcerpc_fault %s in netr_NETRLOGONSETSERVICEBITS\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 919                 }
 920                 break;
 921         }
 922         case 23: {
 923                 struct netr_LogonGetTrustRid *r2 = (struct netr_LogonGetTrustRid *)r;
 924                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 925                         DEBUG(5,("function netr_LogonGetTrustRid replied async\n"));
 926                 }
 927                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 928                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetTrustRid, NDR_OUT | NDR_SET_VALUES, r2);
 929                 }
 930                 if (dce_call->fault_code != 0) {
 931                         DEBUG(2,("dcerpc_fault %s in netr_LogonGetTrustRid\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 932                 }
 933                 break;
 934         }
 935         case 24: {
 936                 struct netr_NETRLOGONCOMPUTESERVERDIGEST *r2 = (struct netr_NETRLOGONCOMPUTESERVERDIGEST *)r;
 937                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 938                         DEBUG(5,("function netr_NETRLOGONCOMPUTESERVERDIGEST replied async\n"));
 939                 }
 940                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 941                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, NDR_OUT | NDR_SET_VALUES, r2);
 942                 }
 943                 if (dce_call->fault_code != 0) {
 944                         DEBUG(2,("dcerpc_fault %s in netr_NETRLOGONCOMPUTESERVERDIGEST\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 945                 }
 946                 break;
 947         }
 948         case 25: {
 949                 struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r2 = (struct netr_NETRLOGONCOMPUTECLIENTDIGEST *)r;
 950                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 951                         DEBUG(5,("function netr_NETRLOGONCOMPUTECLIENTDIGEST replied async\n"));
 952                 }
 953                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 954                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, NDR_OUT | NDR_SET_VALUES, r2);
 955                 }
 956                 if (dce_call->fault_code != 0) {
 957                         DEBUG(2,("dcerpc_fault %s in netr_NETRLOGONCOMPUTECLIENTDIGEST\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 958                 }
 959                 break;
 960         }
 961         case 26: {
 962                 struct netr_ServerAuthenticate3 *r2 = (struct netr_ServerAuthenticate3 *)r;
 963                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 964                         DEBUG(5,("function netr_ServerAuthenticate3 replied async\n"));
 965                 }
 966                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 967                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerAuthenticate3, NDR_OUT | NDR_SET_VALUES, r2);
 968                 }
 969                 if (dce_call->fault_code != 0) {
 970                         DEBUG(2,("dcerpc_fault %s in netr_ServerAuthenticate3\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 971                 }
 972                 break;
 973         }
 974         case 27: {
 975                 struct netr_DsRGetDCNameEx *r2 = (struct netr_DsRGetDCNameEx *)r;
 976                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 977                         DEBUG(5,("function netr_DsRGetDCNameEx replied async\n"));
 978                 }
 979                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 980                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCNameEx, NDR_OUT | NDR_SET_VALUES, r2);
 981                 }
 982                 if (dce_call->fault_code != 0) {
 983                         DEBUG(2,("dcerpc_fault %s in netr_DsRGetDCNameEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 984                 }
 985                 break;
 986         }
 987         case 28: {
 988                 struct netr_DsRGetSiteName *r2 = (struct netr_DsRGetSiteName *)r;
 989                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
 990                         DEBUG(5,("function netr_DsRGetSiteName replied async\n"));
 991                 }
 992                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
 993                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetSiteName, NDR_OUT | NDR_SET_VALUES, r2);
 994                 }
 995                 if (dce_call->fault_code != 0) {
 996                         DEBUG(2,("dcerpc_fault %s in netr_DsRGetSiteName\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
 997                 }
 998                 break;
 999         }
1000         case 29: {
1001                 struct netr_LogonGetDomainInfo *r2 = (struct netr_LogonGetDomainInfo *)r;
1002                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1003                         DEBUG(5,("function netr_LogonGetDomainInfo replied async\n"));
1004                 }
1005                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1006                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonGetDomainInfo, NDR_OUT | NDR_SET_VALUES, r2);
1007                 }
1008                 if (dce_call->fault_code != 0) {
1009                         DEBUG(2,("dcerpc_fault %s in netr_LogonGetDomainInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1010                 }
1011                 break;
1012         }
1013         case 30: {
1014                 struct netr_ServerPasswordSet2 *r2 = (struct netr_ServerPasswordSet2 *)r;
1015                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1016                         DEBUG(5,("function netr_ServerPasswordSet2 replied async\n"));
1017                 }
1018                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1019                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordSet2, NDR_OUT | NDR_SET_VALUES, r2);
1020                 }
1021                 if (dce_call->fault_code != 0) {
1022                         DEBUG(2,("dcerpc_fault %s in netr_ServerPasswordSet2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1023                 }
1024                 break;
1025         }
1026         case 31: {
1027                 struct netr_ServerPasswordGet *r2 = (struct netr_ServerPasswordGet *)r;
1028                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1029                         DEBUG(5,("function netr_ServerPasswordGet replied async\n"));
1030                 }
1031                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1032                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerPasswordGet, NDR_OUT | NDR_SET_VALUES, r2);
1033                 }
1034                 if (dce_call->fault_code != 0) {
1035                         DEBUG(2,("dcerpc_fault %s in netr_ServerPasswordGet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1036                 }
1037                 break;
1038         }
1039         case 32: {
1040                 struct netr_NETRLOGONSENDTOSAM *r2 = (struct netr_NETRLOGONSENDTOSAM *)r;
1041                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1042                         DEBUG(5,("function netr_NETRLOGONSENDTOSAM replied async\n"));
1043                 }
1044                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1045                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONSENDTOSAM, NDR_OUT | NDR_SET_VALUES, r2);
1046                 }
1047                 if (dce_call->fault_code != 0) {
1048                         DEBUG(2,("dcerpc_fault %s in netr_NETRLOGONSENDTOSAM\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1049                 }
1050                 break;
1051         }
1052         case 33: {
1053                 struct netr_DsRAddressToSitenamesW *r2 = (struct netr_DsRAddressToSitenamesW *)r;
1054                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1055                         DEBUG(5,("function netr_DsRAddressToSitenamesW replied async\n"));
1056                 }
1057                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1058                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRAddressToSitenamesW, NDR_OUT | NDR_SET_VALUES, r2);
1059                 }
1060                 if (dce_call->fault_code != 0) {
1061                         DEBUG(2,("dcerpc_fault %s in netr_DsRAddressToSitenamesW\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1062                 }
1063                 break;
1064         }
1065         case 34: {
1066                 struct netr_DsRGetDCNameEx2 *r2 = (struct netr_DsRGetDCNameEx2 *)r;
1067                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1068                         DEBUG(5,("function netr_DsRGetDCNameEx2 replied async\n"));
1069                 }
1070                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1071                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetDCNameEx2, NDR_OUT | NDR_SET_VALUES, r2);
1072                 }
1073                 if (dce_call->fault_code != 0) {
1074                         DEBUG(2,("dcerpc_fault %s in netr_DsRGetDCNameEx2\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1075                 }
1076                 break;
1077         }
1078         case 35: {
1079                 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r2 = (struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *)r;
1080                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1081                         DEBUG(5,("function netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN replied async\n"));
1082                 }
1083                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1084                         NDR_PRINT_FUNCTION_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, NDR_OUT | NDR_SET_VALUES, r2);
1085                 }
1086                 if (dce_call->fault_code != 0) {
1087                         DEBUG(2,("dcerpc_fault %s in netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1088                 }
1089                 break;
1090         }
1091         case 36: {
1092                 struct netr_NetrEnumerateTrustedDomainsEx *r2 = (struct netr_NetrEnumerateTrustedDomainsEx *)r;
1093                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1094                         DEBUG(5,("function netr_NetrEnumerateTrustedDomainsEx replied async\n"));
1095                 }
1096                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1097                         NDR_PRINT_FUNCTION_DEBUG(netr_NetrEnumerateTrustedDomainsEx, NDR_OUT | NDR_SET_VALUES, r2);
1098                 }
1099                 if (dce_call->fault_code != 0) {
1100                         DEBUG(2,("dcerpc_fault %s in netr_NetrEnumerateTrustedDomainsEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1101                 }
1102                 break;
1103         }
1104         case 37: {
1105                 struct netr_DsRAddressToSitenamesExW *r2 = (struct netr_DsRAddressToSitenamesExW *)r;
1106                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1107                         DEBUG(5,("function netr_DsRAddressToSitenamesExW replied async\n"));
1108                 }
1109                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1110                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRAddressToSitenamesExW, NDR_OUT | NDR_SET_VALUES, r2);
1111                 }
1112                 if (dce_call->fault_code != 0) {
1113                         DEBUG(2,("dcerpc_fault %s in netr_DsRAddressToSitenamesExW\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1114                 }
1115                 break;
1116         }
1117         case 38: {
1118                 struct netr_DsrGetDcSiteCoverageW *r2 = (struct netr_DsrGetDcSiteCoverageW *)r;
1119                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1120                         DEBUG(5,("function netr_DsrGetDcSiteCoverageW replied async\n"));
1121                 }
1122                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1123                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrGetDcSiteCoverageW, NDR_OUT | NDR_SET_VALUES, r2);
1124                 }
1125                 if (dce_call->fault_code != 0) {
1126                         DEBUG(2,("dcerpc_fault %s in netr_DsrGetDcSiteCoverageW\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1127                 }
1128                 break;
1129         }
1130         case 39: {
1131                 struct netr_LogonSamLogonEx *r2 = (struct netr_LogonSamLogonEx *)r;
1132                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1133                         DEBUG(5,("function netr_LogonSamLogonEx replied async\n"));
1134                 }
1135                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1136                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogonEx, NDR_OUT | NDR_SET_VALUES, r2);
1137                 }
1138                 if (dce_call->fault_code != 0) {
1139                         DEBUG(2,("dcerpc_fault %s in netr_LogonSamLogonEx\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1140                 }
1141                 break;
1142         }
1143         case 40: {
1144                 struct netr_DsrEnumerateDomainTrusts *r2 = (struct netr_DsrEnumerateDomainTrusts *)r;
1145                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1146                         DEBUG(5,("function netr_DsrEnumerateDomainTrusts replied async\n"));
1147                 }
1148                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1149                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrEnumerateDomainTrusts, NDR_OUT | NDR_SET_VALUES, r2);
1150                 }
1151                 if (dce_call->fault_code != 0) {
1152                         DEBUG(2,("dcerpc_fault %s in netr_DsrEnumerateDomainTrusts\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1153                 }
1154                 break;
1155         }
1156         case 41: {
1157                 struct netr_DsrDeregisterDNSHostRecords *r2 = (struct netr_DsrDeregisterDNSHostRecords *)r;
1158                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1159                         DEBUG(5,("function netr_DsrDeregisterDNSHostRecords replied async\n"));
1160                 }
1161                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1162                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrDeregisterDNSHostRecords, NDR_OUT | NDR_SET_VALUES, r2);
1163                 }
1164                 if (dce_call->fault_code != 0) {
1165                         DEBUG(2,("dcerpc_fault %s in netr_DsrDeregisterDNSHostRecords\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1166                 }
1167                 break;
1168         }
1169         case 42: {
1170                 struct netr_ServerTrustPasswordsGet *r2 = (struct netr_ServerTrustPasswordsGet *)r;
1171                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1172                         DEBUG(5,("function netr_ServerTrustPasswordsGet replied async\n"));
1173                 }
1174                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1175                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerTrustPasswordsGet, NDR_OUT | NDR_SET_VALUES, r2);
1176                 }
1177                 if (dce_call->fault_code != 0) {
1178                         DEBUG(2,("dcerpc_fault %s in netr_ServerTrustPasswordsGet\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1179                 }
1180                 break;
1181         }
1182         case 43: {
1183                 struct netr_DsRGetForestTrustInformation *r2 = (struct netr_DsRGetForestTrustInformation *)r;
1184                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1185                         DEBUG(5,("function netr_DsRGetForestTrustInformation replied async\n"));
1186                 }
1187                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1188                         NDR_PRINT_FUNCTION_DEBUG(netr_DsRGetForestTrustInformation, NDR_OUT | NDR_SET_VALUES, r2);
1189                 }
1190                 if (dce_call->fault_code != 0) {
1191                         DEBUG(2,("dcerpc_fault %s in netr_DsRGetForestTrustInformation\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1192                 }
1193                 break;
1194         }
1195         case 44: {
1196                 struct netr_GetForestTrustInformation *r2 = (struct netr_GetForestTrustInformation *)r;
1197                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1198                         DEBUG(5,("function netr_GetForestTrustInformation replied async\n"));
1199                 }
1200                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1201                         NDR_PRINT_FUNCTION_DEBUG(netr_GetForestTrustInformation, NDR_OUT | NDR_SET_VALUES, r2);
1202                 }
1203                 if (dce_call->fault_code != 0) {
1204                         DEBUG(2,("dcerpc_fault %s in netr_GetForestTrustInformation\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1205                 }
1206                 break;
1207         }
1208         case 45: {
1209                 struct netr_LogonSamLogonWithFlags *r2 = (struct netr_LogonSamLogonWithFlags *)r;
1210                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1211                         DEBUG(5,("function netr_LogonSamLogonWithFlags replied async\n"));
1212                 }
1213                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1214                         NDR_PRINT_FUNCTION_DEBUG(netr_LogonSamLogonWithFlags, NDR_OUT | NDR_SET_VALUES, r2);
1215                 }
1216                 if (dce_call->fault_code != 0) {
1217                         DEBUG(2,("dcerpc_fault %s in netr_LogonSamLogonWithFlags\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1218                 }
1219                 break;
1220         }
1221         case 46: {
1222                 struct netr_ServerGetTrustInfo *r2 = (struct netr_ServerGetTrustInfo *)r;
1223                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1224                         DEBUG(5,("function netr_ServerGetTrustInfo replied async\n"));
1225                 }
1226                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1227                         NDR_PRINT_FUNCTION_DEBUG(netr_ServerGetTrustInfo, NDR_OUT | NDR_SET_VALUES, r2);
1228                 }
1229                 if (dce_call->fault_code != 0) {
1230                         DEBUG(2,("dcerpc_fault %s in netr_ServerGetTrustInfo\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1231                 }
1232                 break;
1233         }
1234         case 47: {
1235                 struct netr_Unused47 *r2 = (struct netr_Unused47 *)r;
1236                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1237                         DEBUG(5,("function netr_Unused47 replied async\n"));
1238                 }
1239                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1240                         NDR_PRINT_FUNCTION_DEBUG(netr_Unused47, NDR_OUT | NDR_SET_VALUES, r2);
1241                 }
1242                 if (dce_call->fault_code != 0) {
1243                         DEBUG(2,("dcerpc_fault %s in netr_Unused47\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1244                 }
1245                 break;
1246         }
1247         case 48: {
1248                 struct netr_DsrUpdateReadOnlyServerDnsRecords *r2 = (struct netr_DsrUpdateReadOnlyServerDnsRecords *)r;
1249                 if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1250                         DEBUG(5,("function netr_DsrUpdateReadOnlyServerDnsRecords replied async\n"));
1251                 }
1252                 if (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {
1253                         NDR_PRINT_FUNCTION_DEBUG(netr_DsrUpdateReadOnlyServerDnsRecords, NDR_OUT | NDR_SET_VALUES, r2);
1254                 }
1255                 if (dce_call->fault_code != 0) {
1256                         DEBUG(2,("dcerpc_fault %s in netr_DsrUpdateReadOnlyServerDnsRecords\n", dcerpc_errstr(mem_ctx, dce_call->fault_code)));
1257                 }
1258                 break;
1259         }
1260
1261         default:
1262                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
1263                 break;
1264         }
1265
1266         if (dce_call->fault_code != 0) {
1267                 dcerpc_log_packet(dce_call->conn->packet_log_dir,
1268                           &ndr_table_netlogon, opnum, NDR_IN,
1269                                   &dce_call->pkt.u.request.stub_and_verifier);
1270                 return NT_STATUS_NET_WRITE_FAULT;
1271         }
1272
1273         return NT_STATUS_OK;
1274 }
1275
1276 static NTSTATUS netlogon__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
1277 {
1278         enum ndr_err_code ndr_err;
1279         uint16_t opnum = dce_call->pkt.u.request.opnum;
1280
1281         ndr_err = ndr_table_netlogon.calls[opnum].ndr_push(push, NDR_OUT, r);
1282         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1283                 dce_call->fault_code = DCERPC_FAULT_NDR;
1284                 return NT_STATUS_NET_WRITE_FAULT;
1285         }
1286
1287         return NT_STATUS_OK;
1288 }
1289
1290 const struct dcesrv_interface dcesrv_netlogon_interface = {
1291         .name           = "netlogon",
1292         .syntax_id  = {{0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0xcf,0xfb}},1.0},
1293         .bind           = netlogon__op_bind,
1294         .unbind         = netlogon__op_unbind,
1295         .ndr_pull       = netlogon__op_ndr_pull,
1296         .dispatch       = netlogon__op_dispatch,
1297         .reply          = netlogon__op_reply,
1298         .ndr_push       = netlogon__op_ndr_push
1299 };
1300
1301
1302 static NTSTATUS netlogon__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
1303 {
1304         int i;
1305
1306         for (i=0;i<ndr_table_netlogon.endpoints->count;i++) {
1307                 NTSTATUS ret;
1308                 const char *name = ndr_table_netlogon.endpoints->names[i];
1309
1310                 ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_netlogon_interface, NULL);
1311                 if (!NT_STATUS_IS_OK(ret)) {
1312                         DEBUG(1,("netlogon_op_init_server: failed to register endpoint '%s'\n",name));
1313                         return ret;
1314                 }
1315         }
1316
1317         return NT_STATUS_OK;
1318 }
1319
1320 static bool netlogon__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
1321 {
1322         if (dcesrv_netlogon_interface.syntax_id.if_version == if_version &&
1323                 GUID_equal(&dcesrv_netlogon_interface.syntax_id.uuid, uuid)) {
1324                 memcpy(iface,&dcesrv_netlogon_interface, sizeof(*iface));
1325                 return true;
1326         }
1327
1328         return false;
1329 }
1330
1331 static bool netlogon__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
1332 {
1333         if (strcmp(dcesrv_netlogon_interface.name, name)==0) {
1334                 memcpy(iface, &dcesrv_netlogon_interface, sizeof(*iface));
1335                 return true;
1336         }
1337
1338         return false;
1339 }
1340
1341 NTSTATUS dcerpc_server_netlogon_init(void)
1342 {
1343         NTSTATUS ret;
1344         struct dcesrv_endpoint_server ep_server;
1345
1346         /* fill in our name */
1347         ep_server.name = "netlogon";
1348
1349         /* fill in all the operations */
1350         ep_server.init_server = netlogon__op_init_server;
1351
1352         ep_server.interface_by_uuid = netlogon__op_interface_by_uuid;
1353         ep_server.interface_by_name = netlogon__op_interface_by_name;
1354
1355         /* register ourselves with the DCERPC subsystem. */
1356         ret = dcerpc_register_ep_server(&ep_server);
1357
1358         if (!NT_STATUS_IS_OK(ret)) {
1359                 DEBUG(0,("Failed to register 'netlogon' endpoint server!\n"));
1360                 return ret;
1361         }
1362
1363         return ret;
1364 }
1365