← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/librpc/rpc/dcerpc.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/librpc/rpc/dcerpc.c
 
1
/* 
 
2
   Unix SMB/CIFS implementation.
 
3
   Samba 4-compatible DCE/RPC API on top of the Samba 3 DCE/RPC client library.
 
4
   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
 
5
   
 
6
   This program is free software; you can redistribute it and/or modify
 
7
   it under the terms of the GNU General Public License as published by
 
8
   the Free Software Foundation; either version 3 of the License, or
 
9
   (at your option) any later version.
 
10
   
 
11
   This program is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
   GNU General Public License for more details.
 
15
   
 
16
   You should have received a copy of the GNU General Public License
 
17
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
*/
 
19
 
 
20
#include "includes.h"
 
21
#include "librpc/rpc/dcerpc.h"
 
22
 
 
23
/** 
 
24
 * Send a struct-based RPC request using the Samba 3 RPC client library.
 
25
 */
 
26
struct rpc_request *dcerpc_ndr_request_send(struct dcerpc_pipe *p, const struct GUID *object, 
 
27
                                            const struct ndr_interface_table *table, uint32_t opnum, 
 
28
                                            TALLOC_CTX *mem_ctx, void *r)
 
29
{
 
30
        const struct ndr_interface_call *call;
 
31
        struct ndr_push *push;
 
32
        struct rpc_request *ret = talloc(mem_ctx, struct rpc_request);
 
33
        enum ndr_err_code ndr_err;
 
34
        DATA_BLOB blob;
 
35
 
 
36
        if (ret == NULL)
 
37
                return NULL;
 
38
 
 
39
        SMB_ASSERT(p->table->num_calls > opnum);
 
40
 
 
41
        call = &p->table->calls[opnum];
 
42
 
 
43
        ret->call = call;
 
44
        ret->r = r;
 
45
 
 
46
        push = ndr_push_init_ctx(mem_ctx, NULL);
 
47
        if (!push) {
 
48
                return NULL;
 
49
        }
 
50
 
 
51
        ndr_err = call->ndr_push(push, NDR_IN, r);
 
52
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
53
                /* FIXME: ndr_map_error2ntstatus(ndr_err); */
 
54
                return NULL;
 
55
        }
 
56
 
 
57
        blob = ndr_push_blob(push);
 
58
 
 
59
        if (!prs_init_data_blob(&ret->q_ps, &blob, mem_ctx)) {
 
60
                return NULL;
 
61
        }
 
62
 
 
63
        talloc_free(push);
 
64
 
 
65
        ret->opnum = opnum;
 
66
 
 
67
        ret->pipe = p;
 
68
 
 
69
        return ret;
 
70
}
 
71
 
 
72
/**
 
73
 * Wait for a DCE/RPC request. 
 
74
 *
 
75
 * @note at the moment this is still sync, even though the API is async.
 
76
 */
 
77
NTSTATUS dcerpc_ndr_request_recv(struct rpc_request *req)
 
78
{
 
79
        prs_struct r_ps;
 
80
        struct ndr_pull *pull;
 
81
        NTSTATUS status;
 
82
        DATA_BLOB blob;
 
83
        enum ndr_err_code ndr_err;
 
84
 
 
85
        prs_init_empty( &r_ps, req, UNMARSHALL );
 
86
 
 
87
        status = rpc_api_pipe_req(req, req->pipe->rpc_cli, req->opnum,
 
88
                                  &req->q_ps, &r_ps);
 
89
 
 
90
        prs_mem_free( &req->q_ps );
 
91
 
 
92
        if (!NT_STATUS_IS_OK(status)) {
 
93
                prs_mem_free( &r_ps );
 
94
                return status;
 
95
        }
 
96
 
 
97
        if (!prs_data_blob(&r_ps, &blob, req)) {
 
98
                prs_mem_free( &r_ps );
 
99
                return NT_STATUS_NO_MEMORY;
 
100
        }
 
101
 
 
102
        prs_mem_free( &r_ps );
 
103
 
 
104
        pull = ndr_pull_init_blob(&blob, req, NULL);
 
105
        if (pull == NULL) {
 
106
                return NT_STATUS_NO_MEMORY;
 
107
        }
 
108
 
 
109
        /* have the ndr parser alloc memory for us */
 
110
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 
111
        ndr_err = req->call->ndr_pull(pull, NDR_OUT, req->r);
 
112
        talloc_free(pull);
 
113
 
 
114
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 
115
                return ndr_map_error2ntstatus(ndr_err);
 
116
        }
 
117
 
 
118
        return NT_STATUS_OK;
 
119
}
 
120
 
 
121
#if 0
 
122
 
 
123
Completely unfinished and unused -- vl :-)
 
124
 
 
125
/**
 
126
 * Connect to a DCE/RPC interface.
 
127
 * 
 
128
 * @note lp_ctx and ev are ignored at the moment but present
 
129
 *      for API compatibility.
 
130
 */
 
131
_PUBLIC_ NTSTATUS dcerpc_pipe_connect(TALLOC_CTX *parent_ctx, struct dcerpc_pipe **pp, 
 
132
                                      const char *binding_string, const struct ndr_interface_table *table, 
 
133
                                      struct cli_credentials *credentials, struct event_context *ev, 
 
134
                                      struct loadparm_context *lp_ctx)
 
135
{
 
136
        struct dcerpc_pipe *p = talloc(parent_ctx, struct dcerpc_pipe);
 
137
        struct dcerpc_binding *binding;
 
138
        NTSTATUS nt_status;
 
139
 
 
140
        nt_status = dcerpc_parse_binding(p, binding_string, &binding);
 
141
 
 
142
        if (NT_STATUS_IS_ERR(nt_status)) {
 
143
                DEBUG(1, ("Unable to parse binding string '%s'", binding_string));
 
144
                talloc_free(p);
 
145
                return nt_status;
 
146
        }
 
147
 
 
148
        if (binding->transport != NCACN_NP) {
 
149
                DEBUG(0, ("Only ncacn_np supported"));
 
150
                talloc_free(p);
 
151
                return NT_STATUS_NOT_SUPPORTED;
 
152
        }
 
153
 
 
154
        /* FIXME: Actually use loadparm_context.. */
 
155
 
 
156
        /* FIXME: actually use credentials */
 
157
 
 
158
        nt_status = cli_full_connection(&p->cli, global_myname(), binding->host,
 
159
                                        NULL, 0, 
 
160
                                        "IPC$", "IPC",
 
161
                                        get_cmdline_auth_info_username(),
 
162
                                        lp_workgroup(),
 
163
                                        get_cmdline_auth_info_password(),
 
164
                                        get_cmdline_auth_info_use_kerberos() ? CLI_FULL_CONNECTION_USE_KERBEROS : 0,
 
165
                                        get_cmdline_auth_info_signing_state(), NULL);
 
166
 
 
167
        if (NT_STATUS_IS_ERR(nt_status)) {
 
168
                talloc_free(p);
 
169
                return nt_status;
 
170
        }
 
171
 
 
172
        nt_status = cli_rpc_pipe_open_noauth(p->cli, &table->syntax_id,
 
173
                                             &p->rpc_cli);
 
174
 
 
175
        if (!NT_STATUS_IS_OK(nt_status)) {
 
176
                talloc_free(p);
 
177
                return nt_status;
 
178
        }
 
179
 
 
180
        p->table = table;
 
181
 
 
182
        *pp = p;
 
183
 
 
184
        return nt_status;
 
185
}
 
186
 
 
187
#endif