Add NT_STATUS_IO_REPARSE_DATA_INVALID
[metze/samba/wip.git] / source3 / winbindd / winbindd_lookuprids.c
1 /*
2    Unix SMB/CIFS implementation.
3    async implementation of WINBINDD_LOOKUPRIDS
4    Copyright (C) Volker Lendecke 2009
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 "winbindd.h"
22 #include "librpc/gen_ndr/ndr_wbint_c.h"
23 #include "../libcli/security/security.h"
24
25 struct winbindd_lookuprids_state {
26         struct tevent_context *ev;
27         const char *domain_name;
28         struct wbint_RidArray rids;
29         struct wbint_Principals names;
30 };
31
32 static bool parse_ridlist(TALLOC_CTX *mem_ctx, char *ridstr,
33                           uint32_t **prids, uint32_t *pnum_rids);
34
35 static void winbindd_lookuprids_done(struct tevent_req *subreq);
36
37 struct tevent_req *winbindd_lookuprids_send(TALLOC_CTX *mem_ctx,
38                                             struct tevent_context *ev,
39                                             struct winbindd_cli_state *cli,
40                                             struct winbindd_request *request)
41 {
42         struct tevent_req *req, *subreq;
43         struct winbindd_lookuprids_state *state;
44         struct winbindd_domain *domain;
45         struct dom_sid sid;
46
47         req = tevent_req_create(mem_ctx, &state,
48                                 struct winbindd_lookuprids_state);
49         if (req == NULL) {
50                 return NULL;
51         }
52         state->ev = ev;
53
54         /* Ensure null termination */
55         request->data.sid[sizeof(request->data.sid)-1]='\0';
56
57         DEBUG(3, ("lookuprids (%s)\n", request->data.sid));
58
59         if (!string_to_sid(&sid, request->data.sid)) {
60                 DEBUG(5, ("%s not a SID\n", request->data.sid));
61                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
62                 return tevent_req_post(req, ev);
63         }
64
65         domain = find_lookup_domain_from_sid(&sid);
66         if (domain == NULL) {
67                 DEBUG(5, ("Domain for sid %s not found\n",
68                           sid_string_dbg(&sid)));
69                 tevent_req_nterror(req, NT_STATUS_NO_SUCH_DOMAIN);
70                 return tevent_req_post(req, ev);
71         }
72
73         if (request->extra_data.data[request->extra_len-1] != '\0') {
74                 DEBUG(5, ("extra_data not 0-terminated\n"));
75                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
76                 return tevent_req_post(req, ev);
77         }
78
79         if (!parse_ridlist(state, request->extra_data.data,
80                            &state->rids.rids, &state->rids.num_rids)) {
81                 DEBUG(5, ("parse_ridlist failed\n"));
82                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
83                 return tevent_req_post(req, ev);
84         }
85
86         subreq = dcerpc_wbint_LookupRids_send(
87                 state, ev, dom_child_handle(domain), &state->rids,
88                 &state->domain_name, &state->names);
89         if (tevent_req_nomem(subreq, req)) {
90                 return tevent_req_post(req, ev);
91         }
92         tevent_req_set_callback(subreq, winbindd_lookuprids_done, req);
93         return req;
94 }
95
96 static void winbindd_lookuprids_done(struct tevent_req *subreq)
97 {
98         struct tevent_req *req = tevent_req_callback_data(
99                 subreq, struct tevent_req);
100         struct winbindd_lookuprids_state *state = tevent_req_data(
101                 req, struct winbindd_lookuprids_state);
102         NTSTATUS status, result;
103
104         status = dcerpc_wbint_LookupRids_recv(subreq, state, &result);
105         TALLOC_FREE(subreq);
106         if (any_nt_status_not_ok(status, result, &status)) {
107                 tevent_req_nterror(req, status);
108                 return;
109         }
110         tevent_req_done(req);
111 }
112
113 NTSTATUS winbindd_lookuprids_recv(struct tevent_req *req,
114                                   struct winbindd_response *response)
115 {
116         struct winbindd_lookuprids_state *state = tevent_req_data(
117                 req, struct winbindd_lookuprids_state);
118         NTSTATUS status;
119         char *result;
120         int i;
121
122         if (tevent_req_is_nterror(req, &status)) {
123                 DEBUG(5, ("Lookuprids failed: %s\n",nt_errstr(status)));
124                 return status;
125         }
126
127         result = talloc_strdup(response, "");
128         if (result == NULL) {
129                 return NT_STATUS_NO_MEMORY;
130         }
131
132         for (i=0; i<state->names.num_principals; i++) {
133                 struct wbint_Principal *p = &state->names.principals[i];
134
135                 result = talloc_asprintf_append_buffer(
136                         result, "%d %s\n", (int)p->type, p->name);
137                 if (result == NULL) {
138                         return NT_STATUS_NO_MEMORY;
139                 }
140         }
141
142         fstrcpy(response->data.domain_name, state->domain_name);
143         response->extra_data.data = result;
144         response->length += talloc_get_size(result);
145         return NT_STATUS_OK;
146 }
147
148 static bool parse_ridlist(TALLOC_CTX *mem_ctx, char *ridstr,
149                           uint32_t **prids, uint32_t *pnum_rids)
150 {
151         uint32_t i, num_rids;
152         uint32_t *rids;
153         char *p;
154
155         if (ridstr == NULL) {
156                 return false;
157         }
158
159         p = ridstr;
160         num_rids = 0;
161
162         /* count rids */
163
164         while ((p = strchr(p, '\n')) != NULL) {
165                 p += 1;
166                 num_rids += 1;
167         }
168
169         if (num_rids == 0) {
170                 *pnum_rids = 0;
171                 *prids = NULL;
172                 return true;
173         }
174
175         rids = talloc_array(mem_ctx, uint32_t, num_rids);
176         if (rids == NULL) {
177                 return false;
178         }
179
180         p = ridstr;
181
182         for (i=0; i<num_rids; i++) {
183                 char *q;
184                 rids[i] = strtoul(p, &q, 10);
185                 if (*q != '\n') {
186                         DEBUG(0, ("Got invalid ridstr: %s\n", p));
187                         return false;
188                 }
189                 p = q+1;
190         }
191
192         *pnum_rids = num_rids;
193         *prids = rids;
194         return true;
195 }