LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_dsbackup.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 0 425 0.0 %
Date: 2024-02-28 12:06:22 Functions: 0 51 0.0 %

          Line data    Source code
       1             : /* parser auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include "bin/default/librpc/gen_ndr/ndr_dsbackup.h"
       5             : 
       6           0 : static enum ndr_err_code ndr_push_HrRBackupPrepare(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupPrepare *r)
       7             : {
       8           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
       9           0 :         if (flags & NDR_IN) {
      10             :         }
      11           0 :         if (flags & NDR_OUT) {
      12             :         }
      13           0 :         return NDR_ERR_SUCCESS;
      14             : }
      15             : 
      16           0 : static enum ndr_err_code ndr_pull_HrRBackupPrepare(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupPrepare *r)
      17             : {
      18           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
      19           0 :         if (flags & NDR_IN) {
      20             :         }
      21           0 :         if (flags & NDR_OUT) {
      22             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
      23             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
      24             :         }
      25           0 :         return NDR_ERR_SUCCESS;
      26             : }
      27             : 
      28           0 : _PUBLIC_ void ndr_print_HrRBackupPrepare(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupPrepare *r)
      29             : {
      30           0 :         ndr_print_struct(ndr, name, "HrRBackupPrepare");
      31           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      32           0 :         ndr->depth++;
      33           0 :         if (flags & NDR_SET_VALUES) {
      34           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
      35             :         }
      36           0 :         if (flags & NDR_IN) {
      37           0 :                 ndr_print_struct(ndr, "in", "HrRBackupPrepare");
      38           0 :                 ndr->depth++;
      39           0 :                 ndr->depth--;
      40             :         }
      41           0 :         if (flags & NDR_OUT) {
      42           0 :                 ndr_print_struct(ndr, "out", "HrRBackupPrepare");
      43           0 :                 ndr->depth++;
      44           0 :                 ndr->depth--;
      45             :         }
      46           0 :         ndr->depth--;
      47             : }
      48             : 
      49           0 : static enum ndr_err_code ndr_push_HrRBackupEnd(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupEnd *r)
      50             : {
      51           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
      52           0 :         if (flags & NDR_IN) {
      53             :         }
      54           0 :         if (flags & NDR_OUT) {
      55             :         }
      56           0 :         return NDR_ERR_SUCCESS;
      57             : }
      58             : 
      59           0 : static enum ndr_err_code ndr_pull_HrRBackupEnd(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupEnd *r)
      60             : {
      61           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
      62           0 :         if (flags & NDR_IN) {
      63             :         }
      64           0 :         if (flags & NDR_OUT) {
      65             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
      66             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
      67             :         }
      68           0 :         return NDR_ERR_SUCCESS;
      69             : }
      70             : 
      71           0 : _PUBLIC_ void ndr_print_HrRBackupEnd(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupEnd *r)
      72             : {
      73           0 :         ndr_print_struct(ndr, name, "HrRBackupEnd");
      74           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
      75           0 :         ndr->depth++;
      76           0 :         if (flags & NDR_SET_VALUES) {
      77           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
      78             :         }
      79           0 :         if (flags & NDR_IN) {
      80           0 :                 ndr_print_struct(ndr, "in", "HrRBackupEnd");
      81           0 :                 ndr->depth++;
      82           0 :                 ndr->depth--;
      83             :         }
      84           0 :         if (flags & NDR_OUT) {
      85           0 :                 ndr_print_struct(ndr, "out", "HrRBackupEnd");
      86           0 :                 ndr->depth++;
      87           0 :                 ndr->depth--;
      88             :         }
      89           0 :         ndr->depth--;
      90             : }
      91             : 
      92           0 : static enum ndr_err_code ndr_push_HrRBackupGetAttachmentInformation(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupGetAttachmentInformation *r)
      93             : {
      94           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
      95           0 :         if (flags & NDR_IN) {
      96             :         }
      97           0 :         if (flags & NDR_OUT) {
      98             :         }
      99           0 :         return NDR_ERR_SUCCESS;
     100             : }
     101             : 
     102           0 : static enum ndr_err_code ndr_pull_HrRBackupGetAttachmentInformation(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupGetAttachmentInformation *r)
     103             : {
     104           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     105           0 :         if (flags & NDR_IN) {
     106             :         }
     107           0 :         if (flags & NDR_OUT) {
     108             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     109             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     110             :         }
     111           0 :         return NDR_ERR_SUCCESS;
     112             : }
     113             : 
     114           0 : _PUBLIC_ void ndr_print_HrRBackupGetAttachmentInformation(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupGetAttachmentInformation *r)
     115             : {
     116           0 :         ndr_print_struct(ndr, name, "HrRBackupGetAttachmentInformation");
     117           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     118           0 :         ndr->depth++;
     119           0 :         if (flags & NDR_SET_VALUES) {
     120           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     121             :         }
     122           0 :         if (flags & NDR_IN) {
     123           0 :                 ndr_print_struct(ndr, "in", "HrRBackupGetAttachmentInformation");
     124           0 :                 ndr->depth++;
     125           0 :                 ndr->depth--;
     126             :         }
     127           0 :         if (flags & NDR_OUT) {
     128           0 :                 ndr_print_struct(ndr, "out", "HrRBackupGetAttachmentInformation");
     129           0 :                 ndr->depth++;
     130           0 :                 ndr->depth--;
     131             :         }
     132           0 :         ndr->depth--;
     133             : }
     134             : 
     135           0 : static enum ndr_err_code ndr_push_HrRBackupOpenFile(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupOpenFile *r)
     136             : {
     137           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     138           0 :         if (flags & NDR_IN) {
     139             :         }
     140           0 :         if (flags & NDR_OUT) {
     141             :         }
     142           0 :         return NDR_ERR_SUCCESS;
     143             : }
     144             : 
     145           0 : static enum ndr_err_code ndr_pull_HrRBackupOpenFile(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupOpenFile *r)
     146             : {
     147           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     148           0 :         if (flags & NDR_IN) {
     149             :         }
     150           0 :         if (flags & NDR_OUT) {
     151             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     152             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     153             :         }
     154           0 :         return NDR_ERR_SUCCESS;
     155             : }
     156             : 
     157           0 : _PUBLIC_ void ndr_print_HrRBackupOpenFile(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupOpenFile *r)
     158             : {
     159           0 :         ndr_print_struct(ndr, name, "HrRBackupOpenFile");
     160           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     161           0 :         ndr->depth++;
     162           0 :         if (flags & NDR_SET_VALUES) {
     163           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     164             :         }
     165           0 :         if (flags & NDR_IN) {
     166           0 :                 ndr_print_struct(ndr, "in", "HrRBackupOpenFile");
     167           0 :                 ndr->depth++;
     168           0 :                 ndr->depth--;
     169             :         }
     170           0 :         if (flags & NDR_OUT) {
     171           0 :                 ndr_print_struct(ndr, "out", "HrRBackupOpenFile");
     172           0 :                 ndr->depth++;
     173           0 :                 ndr->depth--;
     174             :         }
     175           0 :         ndr->depth--;
     176             : }
     177             : 
     178           0 : static enum ndr_err_code ndr_push_HrRBackupRead(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupRead *r)
     179             : {
     180           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     181           0 :         if (flags & NDR_IN) {
     182             :         }
     183           0 :         if (flags & NDR_OUT) {
     184             :         }
     185           0 :         return NDR_ERR_SUCCESS;
     186             : }
     187             : 
     188           0 : static enum ndr_err_code ndr_pull_HrRBackupRead(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupRead *r)
     189             : {
     190           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     191           0 :         if (flags & NDR_IN) {
     192             :         }
     193           0 :         if (flags & NDR_OUT) {
     194             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     195             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     196             :         }
     197           0 :         return NDR_ERR_SUCCESS;
     198             : }
     199             : 
     200           0 : _PUBLIC_ void ndr_print_HrRBackupRead(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupRead *r)
     201             : {
     202           0 :         ndr_print_struct(ndr, name, "HrRBackupRead");
     203           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     204           0 :         ndr->depth++;
     205           0 :         if (flags & NDR_SET_VALUES) {
     206           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     207             :         }
     208           0 :         if (flags & NDR_IN) {
     209           0 :                 ndr_print_struct(ndr, "in", "HrRBackupRead");
     210           0 :                 ndr->depth++;
     211           0 :                 ndr->depth--;
     212             :         }
     213           0 :         if (flags & NDR_OUT) {
     214           0 :                 ndr_print_struct(ndr, "out", "HrRBackupRead");
     215           0 :                 ndr->depth++;
     216           0 :                 ndr->depth--;
     217             :         }
     218           0 :         ndr->depth--;
     219             : }
     220             : 
     221           0 : static enum ndr_err_code ndr_push_HrRBackupClose(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupClose *r)
     222             : {
     223           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     224           0 :         if (flags & NDR_IN) {
     225             :         }
     226           0 :         if (flags & NDR_OUT) {
     227             :         }
     228           0 :         return NDR_ERR_SUCCESS;
     229             : }
     230             : 
     231           0 : static enum ndr_err_code ndr_pull_HrRBackupClose(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupClose *r)
     232             : {
     233           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     234           0 :         if (flags & NDR_IN) {
     235             :         }
     236           0 :         if (flags & NDR_OUT) {
     237             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     238             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     239             :         }
     240           0 :         return NDR_ERR_SUCCESS;
     241             : }
     242             : 
     243           0 : _PUBLIC_ void ndr_print_HrRBackupClose(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupClose *r)
     244             : {
     245           0 :         ndr_print_struct(ndr, name, "HrRBackupClose");
     246           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     247           0 :         ndr->depth++;
     248           0 :         if (flags & NDR_SET_VALUES) {
     249           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     250             :         }
     251           0 :         if (flags & NDR_IN) {
     252           0 :                 ndr_print_struct(ndr, "in", "HrRBackupClose");
     253           0 :                 ndr->depth++;
     254           0 :                 ndr->depth--;
     255             :         }
     256           0 :         if (flags & NDR_OUT) {
     257           0 :                 ndr_print_struct(ndr, "out", "HrRBackupClose");
     258           0 :                 ndr->depth++;
     259           0 :                 ndr->depth--;
     260             :         }
     261           0 :         ndr->depth--;
     262             : }
     263             : 
     264           0 : static enum ndr_err_code ndr_push_HrRBackupGetBackupLogs(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupGetBackupLogs *r)
     265             : {
     266           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     267           0 :         if (flags & NDR_IN) {
     268             :         }
     269           0 :         if (flags & NDR_OUT) {
     270             :         }
     271           0 :         return NDR_ERR_SUCCESS;
     272             : }
     273             : 
     274           0 : static enum ndr_err_code ndr_pull_HrRBackupGetBackupLogs(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupGetBackupLogs *r)
     275             : {
     276           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     277           0 :         if (flags & NDR_IN) {
     278             :         }
     279           0 :         if (flags & NDR_OUT) {
     280             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     281             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     282             :         }
     283           0 :         return NDR_ERR_SUCCESS;
     284             : }
     285             : 
     286           0 : _PUBLIC_ void ndr_print_HrRBackupGetBackupLogs(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupGetBackupLogs *r)
     287             : {
     288           0 :         ndr_print_struct(ndr, name, "HrRBackupGetBackupLogs");
     289           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     290           0 :         ndr->depth++;
     291           0 :         if (flags & NDR_SET_VALUES) {
     292           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     293             :         }
     294           0 :         if (flags & NDR_IN) {
     295           0 :                 ndr_print_struct(ndr, "in", "HrRBackupGetBackupLogs");
     296           0 :                 ndr->depth++;
     297           0 :                 ndr->depth--;
     298             :         }
     299           0 :         if (flags & NDR_OUT) {
     300           0 :                 ndr_print_struct(ndr, "out", "HrRBackupGetBackupLogs");
     301           0 :                 ndr->depth++;
     302           0 :                 ndr->depth--;
     303             :         }
     304           0 :         ndr->depth--;
     305             : }
     306             : 
     307           0 : static enum ndr_err_code ndr_push_HrRBackupTruncateLogs(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupTruncateLogs *r)
     308             : {
     309           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     310           0 :         if (flags & NDR_IN) {
     311             :         }
     312           0 :         if (flags & NDR_OUT) {
     313             :         }
     314           0 :         return NDR_ERR_SUCCESS;
     315             : }
     316             : 
     317           0 : static enum ndr_err_code ndr_pull_HrRBackupTruncateLogs(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupTruncateLogs *r)
     318             : {
     319           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     320           0 :         if (flags & NDR_IN) {
     321             :         }
     322           0 :         if (flags & NDR_OUT) {
     323             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     324             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     325             :         }
     326           0 :         return NDR_ERR_SUCCESS;
     327             : }
     328             : 
     329           0 : _PUBLIC_ void ndr_print_HrRBackupTruncateLogs(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupTruncateLogs *r)
     330             : {
     331           0 :         ndr_print_struct(ndr, name, "HrRBackupTruncateLogs");
     332           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     333           0 :         ndr->depth++;
     334           0 :         if (flags & NDR_SET_VALUES) {
     335           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     336             :         }
     337           0 :         if (flags & NDR_IN) {
     338           0 :                 ndr_print_struct(ndr, "in", "HrRBackupTruncateLogs");
     339           0 :                 ndr->depth++;
     340           0 :                 ndr->depth--;
     341             :         }
     342           0 :         if (flags & NDR_OUT) {
     343           0 :                 ndr_print_struct(ndr, "out", "HrRBackupTruncateLogs");
     344           0 :                 ndr->depth++;
     345           0 :                 ndr->depth--;
     346             :         }
     347           0 :         ndr->depth--;
     348             : }
     349             : 
     350           0 : static enum ndr_err_code ndr_push_HrRBackupPing(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRBackupPing *r)
     351             : {
     352           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     353           0 :         if (flags & NDR_IN) {
     354             :         }
     355           0 :         if (flags & NDR_OUT) {
     356             :         }
     357           0 :         return NDR_ERR_SUCCESS;
     358             : }
     359             : 
     360           0 : static enum ndr_err_code ndr_pull_HrRBackupPing(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRBackupPing *r)
     361             : {
     362           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     363           0 :         if (flags & NDR_IN) {
     364             :         }
     365           0 :         if (flags & NDR_OUT) {
     366             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     367             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     368             :         }
     369           0 :         return NDR_ERR_SUCCESS;
     370             : }
     371             : 
     372           0 : _PUBLIC_ void ndr_print_HrRBackupPing(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRBackupPing *r)
     373             : {
     374           0 :         ndr_print_struct(ndr, name, "HrRBackupPing");
     375           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     376           0 :         ndr->depth++;
     377           0 :         if (flags & NDR_SET_VALUES) {
     378           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     379             :         }
     380           0 :         if (flags & NDR_IN) {
     381           0 :                 ndr_print_struct(ndr, "in", "HrRBackupPing");
     382           0 :                 ndr->depth++;
     383           0 :                 ndr->depth--;
     384             :         }
     385           0 :         if (flags & NDR_OUT) {
     386           0 :                 ndr_print_struct(ndr, "out", "HrRBackupPing");
     387           0 :                 ndr->depth++;
     388           0 :                 ndr->depth--;
     389             :         }
     390           0 :         ndr->depth--;
     391             : }
     392             : 
     393             : #ifndef SKIP_NDR_TABLE_ad_backup
     394             : static const struct ndr_interface_public_struct ad_backup_public_structs[] = {
     395             :         { .name = NULL }
     396             : };
     397             : 
     398             : static const struct ndr_interface_call ad_backup_calls[] = {
     399             :         {
     400             :                 "HrRBackupPrepare",
     401             :                 sizeof(struct HrRBackupPrepare),
     402             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupPrepare,
     403             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupPrepare,
     404             :                 (ndr_print_function_t) ndr_print_HrRBackupPrepare,
     405             :                 { 0, NULL },
     406             :                 { 0, NULL },
     407             :         },
     408             :         {
     409             :                 "HrRBackupEnd",
     410             :                 sizeof(struct HrRBackupEnd),
     411             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupEnd,
     412             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupEnd,
     413             :                 (ndr_print_function_t) ndr_print_HrRBackupEnd,
     414             :                 { 0, NULL },
     415             :                 { 0, NULL },
     416             :         },
     417             :         {
     418             :                 "HrRBackupGetAttachmentInformation",
     419             :                 sizeof(struct HrRBackupGetAttachmentInformation),
     420             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupGetAttachmentInformation,
     421             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupGetAttachmentInformation,
     422             :                 (ndr_print_function_t) ndr_print_HrRBackupGetAttachmentInformation,
     423             :                 { 0, NULL },
     424             :                 { 0, NULL },
     425             :         },
     426             :         {
     427             :                 "HrRBackupOpenFile",
     428             :                 sizeof(struct HrRBackupOpenFile),
     429             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupOpenFile,
     430             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupOpenFile,
     431             :                 (ndr_print_function_t) ndr_print_HrRBackupOpenFile,
     432             :                 { 0, NULL },
     433             :                 { 0, NULL },
     434             :         },
     435             :         {
     436             :                 "HrRBackupRead",
     437             :                 sizeof(struct HrRBackupRead),
     438             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupRead,
     439             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupRead,
     440             :                 (ndr_print_function_t) ndr_print_HrRBackupRead,
     441             :                 { 0, NULL },
     442             :                 { 0, NULL },
     443             :         },
     444             :         {
     445             :                 "HrRBackupClose",
     446             :                 sizeof(struct HrRBackupClose),
     447             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupClose,
     448             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupClose,
     449             :                 (ndr_print_function_t) ndr_print_HrRBackupClose,
     450             :                 { 0, NULL },
     451             :                 { 0, NULL },
     452             :         },
     453             :         {
     454             :                 "HrRBackupGetBackupLogs",
     455             :                 sizeof(struct HrRBackupGetBackupLogs),
     456             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupGetBackupLogs,
     457             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupGetBackupLogs,
     458             :                 (ndr_print_function_t) ndr_print_HrRBackupGetBackupLogs,
     459             :                 { 0, NULL },
     460             :                 { 0, NULL },
     461             :         },
     462             :         {
     463             :                 "HrRBackupTruncateLogs",
     464             :                 sizeof(struct HrRBackupTruncateLogs),
     465             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupTruncateLogs,
     466             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupTruncateLogs,
     467             :                 (ndr_print_function_t) ndr_print_HrRBackupTruncateLogs,
     468             :                 { 0, NULL },
     469             :                 { 0, NULL },
     470             :         },
     471             :         {
     472             :                 "HrRBackupPing",
     473             :                 sizeof(struct HrRBackupPing),
     474             :                 (ndr_push_flags_fn_t) ndr_push_HrRBackupPing,
     475             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRBackupPing,
     476             :                 (ndr_print_function_t) ndr_print_HrRBackupPing,
     477             :                 { 0, NULL },
     478             :                 { 0, NULL },
     479             :         },
     480             :         { .name = NULL }
     481             : };
     482             : 
     483             : static const char * const ad_backup_endpoint_strings[] = {
     484             :         "ncacn_np:[\\pipe\\ad_backup]", 
     485             : };
     486             : 
     487             : static const struct ndr_interface_string_array ad_backup_endpoints = {
     488             :         .count  = 1,
     489             :         .names  = ad_backup_endpoint_strings
     490             : };
     491             : 
     492             : static const char * const ad_backup_authservice_strings[] = {
     493             :         "host", 
     494             : };
     495             : 
     496             : static const struct ndr_interface_string_array ad_backup_authservices = {
     497             :         .count  = 1,
     498             :         .names  = ad_backup_authservice_strings
     499             : };
     500             : 
     501             : 
     502             : const struct ndr_interface_table ndr_table_ad_backup = {
     503             :         .name           = "ad_backup",
     504             :         .syntax_id      = {
     505             :                 {0xecec0d70,0xa603,0x11d0,{0x96,0xb1},{0x00,0xa0,0xc9,0x1e,0xce,0x30}},
     506             :                 NDR_AD_BACKUP_VERSION
     507             :         },
     508             :         .helpstring     = NDR_AD_BACKUP_HELPSTRING,
     509             :         .num_calls      = 9,
     510             :         .calls          = ad_backup_calls,
     511             :         .num_public_structs     = 0,
     512             :         .public_structs         = ad_backup_public_structs,
     513             :         .endpoints      = &ad_backup_endpoints,
     514             :         .authservices   = &ad_backup_authservices
     515             : };
     516             : 
     517             : #endif /* SKIP_NDR_TABLE_ad_backup */
     518           0 : static enum ndr_err_code ndr_push_HrRIsNTDSOnline(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRIsNTDSOnline *r)
     519             : {
     520           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     521           0 :         if (flags & NDR_IN) {
     522             :         }
     523           0 :         if (flags & NDR_OUT) {
     524             :         }
     525           0 :         return NDR_ERR_SUCCESS;
     526             : }
     527             : 
     528           0 : static enum ndr_err_code ndr_pull_HrRIsNTDSOnline(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRIsNTDSOnline *r)
     529             : {
     530           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     531           0 :         if (flags & NDR_IN) {
     532             :         }
     533           0 :         if (flags & NDR_OUT) {
     534             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     535             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     536             :         }
     537           0 :         return NDR_ERR_SUCCESS;
     538             : }
     539             : 
     540           0 : _PUBLIC_ void ndr_print_HrRIsNTDSOnline(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRIsNTDSOnline *r)
     541             : {
     542           0 :         ndr_print_struct(ndr, name, "HrRIsNTDSOnline");
     543           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     544           0 :         ndr->depth++;
     545           0 :         if (flags & NDR_SET_VALUES) {
     546           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     547             :         }
     548           0 :         if (flags & NDR_IN) {
     549           0 :                 ndr_print_struct(ndr, "in", "HrRIsNTDSOnline");
     550           0 :                 ndr->depth++;
     551           0 :                 ndr->depth--;
     552             :         }
     553           0 :         if (flags & NDR_OUT) {
     554           0 :                 ndr_print_struct(ndr, "out", "HrRIsNTDSOnline");
     555           0 :                 ndr->depth++;
     556           0 :                 ndr->depth--;
     557             :         }
     558           0 :         ndr->depth--;
     559             : }
     560             : 
     561           0 : static enum ndr_err_code ndr_push_HrRRestorePrepare(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestorePrepare *r)
     562             : {
     563           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     564           0 :         if (flags & NDR_IN) {
     565             :         }
     566           0 :         if (flags & NDR_OUT) {
     567             :         }
     568           0 :         return NDR_ERR_SUCCESS;
     569             : }
     570             : 
     571           0 : static enum ndr_err_code ndr_pull_HrRRestorePrepare(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestorePrepare *r)
     572             : {
     573           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     574           0 :         if (flags & NDR_IN) {
     575             :         }
     576           0 :         if (flags & NDR_OUT) {
     577             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     578             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     579             :         }
     580           0 :         return NDR_ERR_SUCCESS;
     581             : }
     582             : 
     583           0 : _PUBLIC_ void ndr_print_HrRRestorePrepare(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestorePrepare *r)
     584             : {
     585           0 :         ndr_print_struct(ndr, name, "HrRRestorePrepare");
     586           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     587           0 :         ndr->depth++;
     588           0 :         if (flags & NDR_SET_VALUES) {
     589           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     590             :         }
     591           0 :         if (flags & NDR_IN) {
     592           0 :                 ndr_print_struct(ndr, "in", "HrRRestorePrepare");
     593           0 :                 ndr->depth++;
     594           0 :                 ndr->depth--;
     595             :         }
     596           0 :         if (flags & NDR_OUT) {
     597           0 :                 ndr_print_struct(ndr, "out", "HrRRestorePrepare");
     598           0 :                 ndr->depth++;
     599           0 :                 ndr->depth--;
     600             :         }
     601           0 :         ndr->depth--;
     602             : }
     603             : 
     604           0 : static enum ndr_err_code ndr_push_HrRRestoreRegister(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreRegister *r)
     605             : {
     606           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     607           0 :         if (flags & NDR_IN) {
     608             :         }
     609           0 :         if (flags & NDR_OUT) {
     610             :         }
     611           0 :         return NDR_ERR_SUCCESS;
     612             : }
     613             : 
     614           0 : static enum ndr_err_code ndr_pull_HrRRestoreRegister(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreRegister *r)
     615             : {
     616           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     617           0 :         if (flags & NDR_IN) {
     618             :         }
     619           0 :         if (flags & NDR_OUT) {
     620             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     621             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     622             :         }
     623           0 :         return NDR_ERR_SUCCESS;
     624             : }
     625             : 
     626           0 : _PUBLIC_ void ndr_print_HrRRestoreRegister(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreRegister *r)
     627             : {
     628           0 :         ndr_print_struct(ndr, name, "HrRRestoreRegister");
     629           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     630           0 :         ndr->depth++;
     631           0 :         if (flags & NDR_SET_VALUES) {
     632           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     633             :         }
     634           0 :         if (flags & NDR_IN) {
     635           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreRegister");
     636           0 :                 ndr->depth++;
     637           0 :                 ndr->depth--;
     638             :         }
     639           0 :         if (flags & NDR_OUT) {
     640           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreRegister");
     641           0 :                 ndr->depth++;
     642           0 :                 ndr->depth--;
     643             :         }
     644           0 :         ndr->depth--;
     645             : }
     646             : 
     647           0 : static enum ndr_err_code ndr_push_HrRRestoreRegisterComplete(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreRegisterComplete *r)
     648             : {
     649           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     650           0 :         if (flags & NDR_IN) {
     651             :         }
     652           0 :         if (flags & NDR_OUT) {
     653             :         }
     654           0 :         return NDR_ERR_SUCCESS;
     655             : }
     656             : 
     657           0 : static enum ndr_err_code ndr_pull_HrRRestoreRegisterComplete(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreRegisterComplete *r)
     658             : {
     659           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     660           0 :         if (flags & NDR_IN) {
     661             :         }
     662           0 :         if (flags & NDR_OUT) {
     663             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     664             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     665             :         }
     666           0 :         return NDR_ERR_SUCCESS;
     667             : }
     668             : 
     669           0 : _PUBLIC_ void ndr_print_HrRRestoreRegisterComplete(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreRegisterComplete *r)
     670             : {
     671           0 :         ndr_print_struct(ndr, name, "HrRRestoreRegisterComplete");
     672           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     673           0 :         ndr->depth++;
     674           0 :         if (flags & NDR_SET_VALUES) {
     675           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     676             :         }
     677           0 :         if (flags & NDR_IN) {
     678           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreRegisterComplete");
     679           0 :                 ndr->depth++;
     680           0 :                 ndr->depth--;
     681             :         }
     682           0 :         if (flags & NDR_OUT) {
     683           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreRegisterComplete");
     684           0 :                 ndr->depth++;
     685           0 :                 ndr->depth--;
     686             :         }
     687           0 :         ndr->depth--;
     688             : }
     689             : 
     690           0 : static enum ndr_err_code ndr_push_HrRRestoreGetDatabaseLocations(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreGetDatabaseLocations *r)
     691             : {
     692           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     693           0 :         if (flags & NDR_IN) {
     694             :         }
     695           0 :         if (flags & NDR_OUT) {
     696             :         }
     697           0 :         return NDR_ERR_SUCCESS;
     698             : }
     699             : 
     700           0 : static enum ndr_err_code ndr_pull_HrRRestoreGetDatabaseLocations(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreGetDatabaseLocations *r)
     701             : {
     702           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     703           0 :         if (flags & NDR_IN) {
     704             :         }
     705           0 :         if (flags & NDR_OUT) {
     706             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     707             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     708             :         }
     709           0 :         return NDR_ERR_SUCCESS;
     710             : }
     711             : 
     712           0 : _PUBLIC_ void ndr_print_HrRRestoreGetDatabaseLocations(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreGetDatabaseLocations *r)
     713             : {
     714           0 :         ndr_print_struct(ndr, name, "HrRRestoreGetDatabaseLocations");
     715           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     716           0 :         ndr->depth++;
     717           0 :         if (flags & NDR_SET_VALUES) {
     718           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     719             :         }
     720           0 :         if (flags & NDR_IN) {
     721           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreGetDatabaseLocations");
     722           0 :                 ndr->depth++;
     723           0 :                 ndr->depth--;
     724             :         }
     725           0 :         if (flags & NDR_OUT) {
     726           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreGetDatabaseLocations");
     727           0 :                 ndr->depth++;
     728           0 :                 ndr->depth--;
     729             :         }
     730           0 :         ndr->depth--;
     731             : }
     732             : 
     733           0 : static enum ndr_err_code ndr_push_HrRRestoreEnd(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreEnd *r)
     734             : {
     735           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     736           0 :         if (flags & NDR_IN) {
     737             :         }
     738           0 :         if (flags & NDR_OUT) {
     739             :         }
     740           0 :         return NDR_ERR_SUCCESS;
     741             : }
     742             : 
     743           0 : static enum ndr_err_code ndr_pull_HrRRestoreEnd(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreEnd *r)
     744             : {
     745           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     746           0 :         if (flags & NDR_IN) {
     747             :         }
     748           0 :         if (flags & NDR_OUT) {
     749             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     750             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     751             :         }
     752           0 :         return NDR_ERR_SUCCESS;
     753             : }
     754             : 
     755           0 : _PUBLIC_ void ndr_print_HrRRestoreEnd(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreEnd *r)
     756             : {
     757           0 :         ndr_print_struct(ndr, name, "HrRRestoreEnd");
     758           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     759           0 :         ndr->depth++;
     760           0 :         if (flags & NDR_SET_VALUES) {
     761           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     762             :         }
     763           0 :         if (flags & NDR_IN) {
     764           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreEnd");
     765           0 :                 ndr->depth++;
     766           0 :                 ndr->depth--;
     767             :         }
     768           0 :         if (flags & NDR_OUT) {
     769           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreEnd");
     770           0 :                 ndr->depth++;
     771           0 :                 ndr->depth--;
     772             :         }
     773           0 :         ndr->depth--;
     774             : }
     775             : 
     776           0 : static enum ndr_err_code ndr_push_HrRRestoreSetCurrentLogNumber(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreSetCurrentLogNumber *r)
     777             : {
     778           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     779           0 :         if (flags & NDR_IN) {
     780             :         }
     781           0 :         if (flags & NDR_OUT) {
     782             :         }
     783           0 :         return NDR_ERR_SUCCESS;
     784             : }
     785             : 
     786           0 : static enum ndr_err_code ndr_pull_HrRRestoreSetCurrentLogNumber(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreSetCurrentLogNumber *r)
     787             : {
     788           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     789           0 :         if (flags & NDR_IN) {
     790             :         }
     791           0 :         if (flags & NDR_OUT) {
     792             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     793             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     794             :         }
     795           0 :         return NDR_ERR_SUCCESS;
     796             : }
     797             : 
     798           0 : _PUBLIC_ void ndr_print_HrRRestoreSetCurrentLogNumber(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreSetCurrentLogNumber *r)
     799             : {
     800           0 :         ndr_print_struct(ndr, name, "HrRRestoreSetCurrentLogNumber");
     801           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     802           0 :         ndr->depth++;
     803           0 :         if (flags & NDR_SET_VALUES) {
     804           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     805             :         }
     806           0 :         if (flags & NDR_IN) {
     807           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreSetCurrentLogNumber");
     808           0 :                 ndr->depth++;
     809           0 :                 ndr->depth--;
     810             :         }
     811           0 :         if (flags & NDR_OUT) {
     812           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreSetCurrentLogNumber");
     813           0 :                 ndr->depth++;
     814           0 :                 ndr->depth--;
     815             :         }
     816           0 :         ndr->depth--;
     817             : }
     818             : 
     819           0 : static enum ndr_err_code ndr_push_HrRRestoreCheckLogsForBackup(struct ndr_push *ndr, ndr_flags_type flags, const struct HrRRestoreCheckLogsForBackup *r)
     820             : {
     821           0 :         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
     822           0 :         if (flags & NDR_IN) {
     823             :         }
     824           0 :         if (flags & NDR_OUT) {
     825             :         }
     826           0 :         return NDR_ERR_SUCCESS;
     827             : }
     828             : 
     829           0 : static enum ndr_err_code ndr_pull_HrRRestoreCheckLogsForBackup(struct ndr_pull *ndr, ndr_flags_type flags, struct HrRRestoreCheckLogsForBackup *r)
     830             : {
     831           0 :         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
     832           0 :         if (flags & NDR_IN) {
     833             :         }
     834           0 :         if (flags & NDR_OUT) {
     835             : #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     836             : #endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
     837             :         }
     838           0 :         return NDR_ERR_SUCCESS;
     839             : }
     840             : 
     841           0 : _PUBLIC_ void ndr_print_HrRRestoreCheckLogsForBackup(struct ndr_print *ndr, const char *name, ndr_flags_type flags, const struct HrRRestoreCheckLogsForBackup *r)
     842             : {
     843           0 :         ndr_print_struct(ndr, name, "HrRRestoreCheckLogsForBackup");
     844           0 :         if (r == NULL) { ndr_print_null(ndr); return; }
     845           0 :         ndr->depth++;
     846           0 :         if (flags & NDR_SET_VALUES) {
     847           0 :                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
     848             :         }
     849           0 :         if (flags & NDR_IN) {
     850           0 :                 ndr_print_struct(ndr, "in", "HrRRestoreCheckLogsForBackup");
     851           0 :                 ndr->depth++;
     852           0 :                 ndr->depth--;
     853             :         }
     854           0 :         if (flags & NDR_OUT) {
     855           0 :                 ndr_print_struct(ndr, "out", "HrRRestoreCheckLogsForBackup");
     856           0 :                 ndr->depth++;
     857           0 :                 ndr->depth--;
     858             :         }
     859           0 :         ndr->depth--;
     860             : }
     861             : 
     862             : #ifndef SKIP_NDR_TABLE_ad_restore
     863             : static const struct ndr_interface_public_struct ad_restore_public_structs[] = {
     864             :         { .name = NULL }
     865             : };
     866             : 
     867             : static const struct ndr_interface_call ad_restore_calls[] = {
     868             :         {
     869             :                 "HrRIsNTDSOnline",
     870             :                 sizeof(struct HrRIsNTDSOnline),
     871             :                 (ndr_push_flags_fn_t) ndr_push_HrRIsNTDSOnline,
     872             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRIsNTDSOnline,
     873             :                 (ndr_print_function_t) ndr_print_HrRIsNTDSOnline,
     874             :                 { 0, NULL },
     875             :                 { 0, NULL },
     876             :         },
     877             :         {
     878             :                 "HrRRestorePrepare",
     879             :                 sizeof(struct HrRRestorePrepare),
     880             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestorePrepare,
     881             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestorePrepare,
     882             :                 (ndr_print_function_t) ndr_print_HrRRestorePrepare,
     883             :                 { 0, NULL },
     884             :                 { 0, NULL },
     885             :         },
     886             :         {
     887             :                 "HrRRestoreRegister",
     888             :                 sizeof(struct HrRRestoreRegister),
     889             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreRegister,
     890             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreRegister,
     891             :                 (ndr_print_function_t) ndr_print_HrRRestoreRegister,
     892             :                 { 0, NULL },
     893             :                 { 0, NULL },
     894             :         },
     895             :         {
     896             :                 "HrRRestoreRegisterComplete",
     897             :                 sizeof(struct HrRRestoreRegisterComplete),
     898             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreRegisterComplete,
     899             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreRegisterComplete,
     900             :                 (ndr_print_function_t) ndr_print_HrRRestoreRegisterComplete,
     901             :                 { 0, NULL },
     902             :                 { 0, NULL },
     903             :         },
     904             :         {
     905             :                 "HrRRestoreGetDatabaseLocations",
     906             :                 sizeof(struct HrRRestoreGetDatabaseLocations),
     907             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreGetDatabaseLocations,
     908             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreGetDatabaseLocations,
     909             :                 (ndr_print_function_t) ndr_print_HrRRestoreGetDatabaseLocations,
     910             :                 { 0, NULL },
     911             :                 { 0, NULL },
     912             :         },
     913             :         {
     914             :                 "HrRRestoreEnd",
     915             :                 sizeof(struct HrRRestoreEnd),
     916             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreEnd,
     917             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreEnd,
     918             :                 (ndr_print_function_t) ndr_print_HrRRestoreEnd,
     919             :                 { 0, NULL },
     920             :                 { 0, NULL },
     921             :         },
     922             :         {
     923             :                 "HrRRestoreSetCurrentLogNumber",
     924             :                 sizeof(struct HrRRestoreSetCurrentLogNumber),
     925             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreSetCurrentLogNumber,
     926             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreSetCurrentLogNumber,
     927             :                 (ndr_print_function_t) ndr_print_HrRRestoreSetCurrentLogNumber,
     928             :                 { 0, NULL },
     929             :                 { 0, NULL },
     930             :         },
     931             :         {
     932             :                 "HrRRestoreCheckLogsForBackup",
     933             :                 sizeof(struct HrRRestoreCheckLogsForBackup),
     934             :                 (ndr_push_flags_fn_t) ndr_push_HrRRestoreCheckLogsForBackup,
     935             :                 (ndr_pull_flags_fn_t) ndr_pull_HrRRestoreCheckLogsForBackup,
     936             :                 (ndr_print_function_t) ndr_print_HrRRestoreCheckLogsForBackup,
     937             :                 { 0, NULL },
     938             :                 { 0, NULL },
     939             :         },
     940             :         { .name = NULL }
     941             : };
     942             : 
     943             : static const char * const ad_restore_endpoint_strings[] = {
     944             :         "ncacn_np:[\\pipe\\ad_restore]", 
     945             : };
     946             : 
     947             : static const struct ndr_interface_string_array ad_restore_endpoints = {
     948             :         .count  = 1,
     949             :         .names  = ad_restore_endpoint_strings
     950             : };
     951             : 
     952             : static const char * const ad_restore_authservice_strings[] = {
     953             :         "host", 
     954             : };
     955             : 
     956             : static const struct ndr_interface_string_array ad_restore_authservices = {
     957             :         .count  = 1,
     958             :         .names  = ad_restore_authservice_strings
     959             : };
     960             : 
     961             : 
     962             : const struct ndr_interface_table ndr_table_ad_restore = {
     963             :         .name           = "ad_restore",
     964             :         .syntax_id      = {
     965             :                 {0x16e0cf3a,0xa604,0x11d0,{0x96,0xb1},{0x00,0xa0,0xc9,0x1e,0xce,0x30}},
     966             :                 NDR_AD_RESTORE_VERSION
     967             :         },
     968             :         .helpstring     = NDR_AD_RESTORE_HELPSTRING,
     969             :         .num_calls      = 8,
     970             :         .calls          = ad_restore_calls,
     971             :         .num_public_structs     = 0,
     972             :         .public_structs         = ad_restore_public_structs,
     973             :         .endpoints      = &ad_restore_endpoints,
     974             :         .authservices   = &ad_restore_authservices
     975             : };
     976             : 
     977             : #endif /* SKIP_NDR_TABLE_ad_restore */

Generated by: LCOV version 1.14