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         if ((*r.out.num_ents) > (r.in.max_ents)) {
 139                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 140         }
 141         memcpy(entries, r.out.entries, (*r.out.num_ents) * sizeof(*entries));
 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->dispatch(cli,
 170                                 mem_ctx,
 171                                 &ndr_table_epmapper,
 172                                 NDR_EPM_MAP,
 173                                 &r);
 174
 175         if (!NT_STATUS_IS_OK(status)) {
 176                 return status;
 177         }
 178
 179         if (DEBUGLEVEL >= 10) {
 180                 NDR_PRINT_OUT_DEBUG(epm_Map, &r);
 181         }
 182
 183         if (NT_STATUS_IS_ERR(status)) {
 184                 return status;
 185         }
 186
 187         /* Return variables */
 188         *entry_handle = *r.out.entry_handle;
 189         *num_towers = *r.out.num_towers;
 190         if ((*r.out.num_towers) > (r.in.max_towers)) {
 191                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 192         }
 193         memcpy(towers, r.out.towers, (*r.out.num_towers) * sizeof(*towers));
 194
 195         /* Return result */
 196         return NT_STATUS_OK;
 197 }
 198
 199 NTSTATUS rpccli_epm_LookupHandleFree(struct rpc_pipe_client *cli,
 200                                      TALLOC_CTX *mem_ctx,
 201                                      struct policy_handle *entry_handle /* [in,out] [ref] */)
 202 {
 203         struct epm_LookupHandleFree r;
 204         NTSTATUS status;
 205
 206         /* In parameters */
 207         r.in.entry_handle = entry_handle;
 208
 209         if (DEBUGLEVEL >= 10) {
 210                 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, &r);
 211         }
 212
 213         status = cli->dispatch(cli,
 214                                 mem_ctx,
 215                                 &ndr_table_epmapper,
 216                                 NDR_EPM_LOOKUPHANDLEFREE,
 217                                 &r);
 218
 219         if (!NT_STATUS_IS_OK(status)) {
 220                 return status;
 221         }
 222
 223         if (DEBUGLEVEL >= 10) {
 224                 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, &r);
 225         }
 226
 227         if (NT_STATUS_IS_ERR(status)) {
 228                 return status;
 229         }
 230
 231         /* Return variables */
 232         *entry_handle = *r.out.entry_handle;
 233
 234         /* Return result */
 235         return NT_STATUS_OK;
 236 }
 237
 238 NTSTATUS rpccli_epm_InqObject(struct rpc_pipe_client *cli,
 239                               TALLOC_CTX *mem_ctx,
 240                               struct GUID *epm_object /* [in] [ref] */)
 241 {
 242         struct epm_InqObject r;
 243         NTSTATUS status;
 244
 245         /* In parameters */
 246         r.in.epm_object = epm_object;
 247
 248         if (DEBUGLEVEL >= 10) {
 249                 NDR_PRINT_IN_DEBUG(epm_InqObject, &r);
 250         }
 251
 252         status = cli->dispatch(cli,
 253                                 mem_ctx,
 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->dispatch(cli,
 295                                 mem_ctx,
 296                                 &ndr_table_epmapper,
 297                                 NDR_EPM_MGMTDELETE,
 298                                 &r);
 299
 300         if (!NT_STATUS_IS_OK(status)) {
 301                 return status;
 302         }
 303
 304         if (DEBUGLEVEL >= 10) {
 305                 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, &r);
 306         }
 307
 308         if (NT_STATUS_IS_ERR(status)) {
 309                 return status;
 310         }
 311
 312         /* Return variables */
 313
 314         /* Return result */
 315         return NT_STATUS_OK;
 316 }
 317
 318 NTSTATUS rpccli_epm_MapAuth(struct rpc_pipe_client *cli,
 319                             TALLOC_CTX *mem_ctx)
 320 {
 321         struct epm_MapAuth r;
 322         NTSTATUS status;
 323
 324         /* In parameters */
 325
 326         if (DEBUGLEVEL >= 10) {
 327                 NDR_PRINT_IN_DEBUG(epm_MapAuth, &r);
 328         }
 329
 330         status = cli->dispatch(cli,
 331                                 mem_ctx,
 332                                 &ndr_table_epmapper,
 333                                 NDR_EPM_MAPAUTH,
 334                                 &r);
 335
 336         if (!NT_STATUS_IS_OK(status)) {
 337                 return status;
 338         }
 339
 340         if (DEBUGLEVEL >= 10) {
 341                 NDR_PRINT_OUT_DEBUG(epm_MapAuth, &r);
 342         }
 343
 344         if (NT_STATUS_IS_ERR(status)) {
 345                 return status;
 346         }
 347
 348         /* Return variables */
 349
 350         /* Return result */
 351         return NT_STATUS_OK;
 352 }
 353