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