librpc/gen_ndr/cli_epmapper.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/cli_epmapper.h"
   8
   9 NTSTATUS rpccli_epm_Insert(struct rpc_pipe_client *cli,
  10                            TALLOC_CTX *mem_ctx,
  11                            uint32_t num_ents /* [in]  */,
  12                            struct epm_entry_t *entries /* [in] [size_is(num_ents)] */,
  13                            uint32_t replace /* [in]  */)
  14 {
  15         struct epm_Insert r;
  16         NTSTATUS status;
  17
  18         /* In parameters */
  19         r.in.num_ents = num_ents;
  20         r.in.entries = entries;
  21         r.in.replace = replace;
  22
  23         if (DEBUGLEVEL >= 10) {
  24                 NDR_PRINT_IN_DEBUG(epm_Insert, &r);
  25         }
  26
  27         status = cli->dispatch(cli,
  28                                 mem_ctx,
  29                                 &ndr_table_epmapper,
  30                                 NDR_EPM_INSERT,
  31                                 &r);
  32
  33         if (!NT_STATUS_IS_OK(status)) {
  34                 return status;
  35         }
  36
  37         if (DEBUGLEVEL >= 10) {
  38                 NDR_PRINT_OUT_DEBUG(epm_Insert, &r);
  39         }
  40
  41         if (NT_STATUS_IS_ERR(status)) {
  42                 return status;
  43         }
  44
  45         /* Return variables */
  46
  47         /* Return result */
  48         return NT_STATUS_OK;
  49 }
  50
  51 NTSTATUS rpccli_epm_Delete(struct rpc_pipe_client *cli,
  52                            TALLOC_CTX *mem_ctx,
  53                            uint32_t num_ents /* [in]  */,
  54                            struct epm_entry_t *entries /* [in] [size_is(num_ents)] */)
  55 {
  56         struct epm_Delete r;
  57         NTSTATUS status;
  58
  59         /* In parameters */
  60         r.in.num_ents = num_ents;
  61         r.in.entries = entries;
  62
  63         if (DEBUGLEVEL >= 10) {
  64                 NDR_PRINT_IN_DEBUG(epm_Delete, &r);
  65         }
  66
  67         status = cli->dispatch(cli,
  68                                 mem_ctx,
  69                                 &ndr_table_epmapper,
  70                                 NDR_EPM_DELETE,
  71                                 &r);
  72
  73         if (!NT_STATUS_IS_OK(status)) {
  74                 return status;
  75         }
  76
  77         if (DEBUGLEVEL >= 10) {
  78                 NDR_PRINT_OUT_DEBUG(epm_Delete, &r);
  79         }
  80
  81         if (NT_STATUS_IS_ERR(status)) {
  82                 return status;
  83         }
  84
  85         /* Return variables */
  86
  87         /* Return result */
  88         return NT_STATUS_OK;
  89 }
  90
  91 NTSTATUS rpccli_epm_Lookup(struct rpc_pipe_client *cli,
  92                            TALLOC_CTX *mem_ctx,
  93                            uint32_t inquiry_type /* [in]  */,
  94                            struct GUID *object /* [in] [ptr] */,
  95                            struct rpc_if_id_t *interface_id /* [in] [ptr] */,
  96                            uint32_t vers_option /* [in]  */,
  97                            struct policy_handle *entry_handle /* [in,out] [ref] */,
  98                            uint32_t max_ents /* [in]  */,
  99                            uint32_t *num_ents /* [out] [ref] */,
 100                            struct epm_entry_t *entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
 101 {
 102         struct epm_Lookup r;
 103         NTSTATUS status;
 104
 105         /* In parameters */
 106         r.in.inquiry_type = inquiry_type;
 107         r.in.object = object;
 108         r.in.interface_id = interface_id;
 109         r.in.vers_option = vers_option;
 110         r.in.entry_handle = entry_handle;
 111         r.in.max_ents = max_ents;
 112
 113         if (DEBUGLEVEL >= 10) {
 114                 NDR_PRINT_IN_DEBUG(epm_Lookup, &r);
 115         }
 116
 117         status = cli->dispatch(cli,
 118                                 mem_ctx,
 119                                 &ndr_table_epmapper,
 120                                 NDR_EPM_LOOKUP,
 121                                 &r);
 122
 123         if (!NT_STATUS_IS_OK(status)) {
 124                 return status;
 125         }
 126
 127         if (DEBUGLEVEL >= 10) {
 128                 NDR_PRINT_OUT_DEBUG(epm_Lookup, &r);
 129         }
 130
 131         if (NT_STATUS_IS_ERR(status)) {
 132                 return status;
 133         }
 134
 135         /* Return variables */
 136         *entry_handle = *r.out.entry_handle;
 137         *num_ents = *r.out.num_ents;
 138         memcpy(entries, r.out.entries, r.in.max_ents * sizeof(*entries));
 139
 140         /* Return result */
 141         return NT_STATUS_OK;
 142 }
 143
 144 NTSTATUS rpccli_epm_Map(struct rpc_pipe_client *cli,
 145                         TALLOC_CTX *mem_ctx,
 146                         struct GUID *object /* [in] [ptr] */,
 147                         struct epm_twr_t *map_tower /* [in] [ptr] */,
 148                         struct policy_handle *entry_handle /* [in,out] [ref] */,
 149                         uint32_t max_towers /* [in]  */,
 150                         uint32_t *num_towers /* [out] [ref] */,
 151                         struct epm_twr_p_t *towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
 152 {
 153         struct epm_Map r;
 154         NTSTATUS status;
 155
 156         /* In parameters */
 157         r.in.object = object;
 158         r.in.map_tower = map_tower;
 159         r.in.entry_handle = entry_handle;
 160         r.in.max_towers = max_towers;
 161
 162         if (DEBUGLEVEL >= 10) {
 163                 NDR_PRINT_IN_DEBUG(epm_Map, &r);
 164         }
 165
 166         status = cli->dispatch(cli,
 167                                 mem_ctx,
 168                                 &ndr_table_epmapper,
 169                                 NDR_EPM_MAP,
 170                                 &r);
 171
 172         if (!NT_STATUS_IS_OK(status)) {
 173                 return status;
 174         }
 175
 176         if (DEBUGLEVEL >= 10) {
 177                 NDR_PRINT_OUT_DEBUG(epm_Map, &r);
 178         }
 179
 180         if (NT_STATUS_IS_ERR(status)) {
 181                 return status;
 182         }
 183
 184         /* Return variables */
 185         *entry_handle = *r.out.entry_handle;
 186         *num_towers = *r.out.num_towers;
 187         memcpy(towers, r.out.towers, r.in.max_towers * sizeof(*towers));
 188
 189         /* Return result */
 190         return NT_STATUS_OK;
 191 }
 192
 193 NTSTATUS rpccli_epm_LookupHandleFree(struct rpc_pipe_client *cli,
 194                                      TALLOC_CTX *mem_ctx,
 195                                      struct policy_handle *entry_handle /* [in,out] [ref] */)
 196 {
 197         struct epm_LookupHandleFree r;
 198         NTSTATUS status;
 199
 200         /* In parameters */
 201         r.in.entry_handle = entry_handle;
 202
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, &r);
 205         }
 206
 207         status = cli->dispatch(cli,
 208                                 mem_ctx,
 209                                 &ndr_table_epmapper,
 210                                 NDR_EPM_LOOKUPHANDLEFREE,
 211                                 &r);
 212
 213         if (!NT_STATUS_IS_OK(status)) {
 214                 return status;
 215         }
 216
 217         if (DEBUGLEVEL >= 10) {
 218                 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, &r);
 219         }
 220
 221         if (NT_STATUS_IS_ERR(status)) {
 222                 return status;
 223         }
 224
 225         /* Return variables */
 226         *entry_handle = *r.out.entry_handle;
 227
 228         /* Return result */
 229         return NT_STATUS_OK;
 230 }
 231
 232 NTSTATUS rpccli_epm_InqObject(struct rpc_pipe_client *cli,
 233                               TALLOC_CTX *mem_ctx,
 234                               struct GUID *epm_object /* [in] [ref] */)
 235 {
 236         struct epm_InqObject r;
 237         NTSTATUS status;
 238
 239         /* In parameters */
 240         r.in.epm_object = epm_object;
 241
 242         if (DEBUGLEVEL >= 10) {
 243                 NDR_PRINT_IN_DEBUG(epm_InqObject, &r);
 244         }
 245
 246         status = cli->dispatch(cli,
 247                                 mem_ctx,
 248                                 &ndr_table_epmapper,
 249                                 NDR_EPM_INQOBJECT,
 250                                 &r);
 251
 252         if (!NT_STATUS_IS_OK(status)) {
 253                 return status;
 254         }
 255
 256         if (DEBUGLEVEL >= 10) {
 257                 NDR_PRINT_OUT_DEBUG(epm_InqObject, &r);
 258         }
 259
 260         if (NT_STATUS_IS_ERR(status)) {
 261                 return status;
 262         }
 263
 264         /* Return variables */
 265
 266         /* Return result */
 267         return NT_STATUS_OK;
 268 }
 269
 270 NTSTATUS rpccli_epm_MgmtDelete(struct rpc_pipe_client *cli,
 271                                TALLOC_CTX *mem_ctx,
 272                                uint32_t object_speced /* [in]  */,
 273                                struct GUID *object /* [in] [ptr] */,
 274                                struct epm_twr_t *tower /* [in] [ptr] */)
 275 {
 276         struct epm_MgmtDelete r;
 277         NTSTATUS status;
 278
 279         /* In parameters */
 280         r.in.object_speced = object_speced;
 281         r.in.object = object;
 282         r.in.tower = tower;
 283
 284         if (DEBUGLEVEL >= 10) {
 285                 NDR_PRINT_IN_DEBUG(epm_MgmtDelete, &r);
 286         }
 287
 288         status = cli->dispatch(cli,
 289                                 mem_ctx,
 290                                 &ndr_table_epmapper,
 291                                 NDR_EPM_MGMTDELETE,
 292                                 &r);
 293
 294         if (!NT_STATUS_IS_OK(status)) {
 295                 return status;
 296         }
 297
 298         if (DEBUGLEVEL >= 10) {
 299                 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, &r);
 300         }
 301
 302         if (NT_STATUS_IS_ERR(status)) {
 303                 return status;
 304         }
 305
 306         /* Return variables */
 307
 308         /* Return result */
 309         return NT_STATUS_OK;
 310 }
 311
 312 NTSTATUS rpccli_epm_MapAuth(struct rpc_pipe_client *cli,
 313                             TALLOC_CTX *mem_ctx)
 314 {
 315         struct epm_MapAuth r;
 316         NTSTATUS status;
 317
 318         /* In parameters */
 319
 320         if (DEBUGLEVEL >= 10) {
 321                 NDR_PRINT_IN_DEBUG(epm_MapAuth, &r);
 322         }
 323
 324         status = cli->dispatch(cli,
 325                                 mem_ctx,
 326                                 &ndr_table_epmapper,
 327                                 NDR_EPM_MAPAUTH,
 328                                 &r);
 329
 330         if (!NT_STATUS_IS_OK(status)) {
 331                 return status;
 332         }
 333
 334         if (DEBUGLEVEL >= 10) {
 335                 NDR_PRINT_OUT_DEBUG(epm_MapAuth, &r);
 336         }
 337
 338         if (NT_STATUS_IS_ERR(status)) {
 339                 return status;
 340         }
 341
 342         /* Return variables */
 343
 344         /* Return result */
 345         return NT_STATUS_OK;
 346 }
 347