*id_to_*id call reshape to return NTSTATUS errors
[ira/wip.git] / source3 / nsswitch / winbindd_sid.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind daemon - sid related functions
5
6    Copyright (C) Tim Potter 2000
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "winbindd.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_WINBIND
27
28 /* Convert a string  */
29
30 enum winbindd_result winbindd_lookupsid(struct winbindd_cli_state *state)
31 {
32         extern DOM_SID global_sid_Builtin;
33         enum SID_NAME_USE type;
34         DOM_SID sid, tmp_sid;
35         uint32 rid;
36         fstring name;
37         fstring dom_name;
38
39         /* Ensure null termination */
40         state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
41
42         DEBUG(3, ("[%5d]: lookupsid %s\n", state->pid, 
43                   state->request.data.sid));
44
45         /* Lookup sid from PDC using lsa_lookup_sids() */
46
47         if (!string_to_sid(&sid, state->request.data.sid)) {
48                 DEBUG(5, ("%s not a SID\n", state->request.data.sid));
49                 return WINBINDD_ERROR;
50         }
51
52         /* Don't look up BUILTIN sids */
53
54         sid_copy(&tmp_sid, &sid);
55         sid_split_rid(&tmp_sid, &rid);
56
57         if (sid_equal(&tmp_sid, &global_sid_Builtin)) {
58                 return WINBINDD_ERROR;
59         }
60
61         /* Lookup the sid */
62
63         if (!winbindd_lookup_name_by_sid(&sid, dom_name, name, &type)) {
64                 return WINBINDD_ERROR;
65         }
66
67         fstrcpy(state->response.data.name.dom_name, dom_name);
68         fstrcpy(state->response.data.name.name, name);
69
70         state->response.data.name.type = type;
71
72         return WINBINDD_OK;
73 }
74
75
76 /**
77  * Look up the SID for a qualified name.  
78  **/
79 enum winbindd_result winbindd_lookupname(struct winbindd_cli_state *state)
80 {
81         enum SID_NAME_USE type;
82         fstring sid_str;
83         char *name_domain, *name_user;
84         DOM_SID sid;
85         struct winbindd_domain *domain;
86
87         /* Ensure null termination */
88         state->request.data.sid[sizeof(state->request.data.name.dom_name)-1]='\0';
89
90         /* Ensure null termination */
91         state->request.data.sid[sizeof(state->request.data.name.name)-1]='\0';
92
93         DEBUG(3, ("[%5d]: lookupname %s%s%s\n", state->pid,
94                   state->request.data.name.dom_name, 
95                   lp_winbind_separator(),
96                   state->request.data.name.name));
97
98         name_domain = state->request.data.name.dom_name;
99         name_user = state->request.data.name.name;
100
101         if ((domain = find_domain_from_name(name_domain)) == NULL) {
102                 DEBUG(0, ("could not find domain entry for domain %s\n", 
103                           name_domain));
104                 return WINBINDD_ERROR;
105         }
106
107         /* Lookup name from PDC using lsa_lookup_names() */
108         if (!winbindd_lookup_sid_by_name(domain, name_user, &sid, &type)) {
109                 return WINBINDD_ERROR;
110         }
111
112         sid_to_string(sid_str, &sid);
113         fstrcpy(state->response.data.sid.sid, sid_str);
114         state->response.data.sid.type = type;
115
116         return WINBINDD_OK;
117 }
118
119 /* Convert a sid to a uid.  We assume we only have one rid attached to the
120    sid. */
121
122 enum winbindd_result winbindd_sid_to_uid(struct winbindd_cli_state *state)
123 {
124         DOM_SID sid;
125
126         /* Ensure null termination */
127         state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
128
129         DEBUG(3, ("[%5d]: sid to uid %s\n", state->pid,
130                   state->request.data.sid));
131
132         /* Split sid into domain sid and user rid */
133         if (!string_to_sid(&sid, state->request.data.sid)) {
134                 DEBUG(1, ("Could not get convert sid %s from string\n",
135                           state->request.data.sid));
136                 return WINBINDD_ERROR;
137         }
138
139         /* Find uid for this sid and return it */
140         if (NT_STATUS_IS_ERR(sid_to_uid(&sid, &(state->response.data.uid)))) {
141                 DEBUG(1, ("Could not get uid for sid %s\n",
142                           state->request.data.sid));
143                 return WINBINDD_ERROR;
144         }
145
146         return WINBINDD_OK;
147 }
148
149 /* Convert a sid to a gid.  We assume we only have one rid attached to the
150    sid.*/
151
152 enum winbindd_result winbindd_sid_to_gid(struct winbindd_cli_state *state)
153 {
154         DOM_SID sid;
155
156         /* Ensure null termination */
157         state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
158
159         DEBUG(3, ("[%5d]: sid to gid %s\n", state->pid, 
160                   state->request.data.sid));
161
162         if (!string_to_sid(&sid, state->request.data.sid)) {
163                 DEBUG(1, ("Could not cvt string to sid %s\n",
164                           state->request.data.sid));
165                 return WINBINDD_ERROR;
166         }
167
168         /* Find gid for this sid and return it */
169         if (NT_STATUS_IS_ERR(sid_to_gid(&sid, &(state->response.data.gid)))) {
170                 DEBUG(1, ("Could not get gid for sid %s\n",
171                           state->request.data.sid));
172                 return WINBINDD_ERROR;
173         }
174
175         return WINBINDD_OK;
176 }
177
178 /* Convert a uid to a sid */
179
180 enum winbindd_result winbindd_uid_to_sid(struct winbindd_cli_state *state)
181 {
182         DOM_SID sid;
183
184         /* Bug out if the uid isn't in the winbind range */
185
186         if ((state->request.data.uid < server_state.uid_low ) ||
187             (state->request.data.uid > server_state.uid_high)) {
188                 return WINBINDD_ERROR;
189         }
190
191         DEBUG(3, ("[%5d]: uid to sid %d\n", state->pid, 
192                   state->request.data.uid));
193
194         /* Lookup rid for this uid */
195         if (NT_STATUS_IS_ERR(uid_to_sid(&sid, state->request.data.uid))) {
196                 DEBUG(1, ("Could not convert uid %d to rid\n",
197                           state->request.data.uid));
198                 return WINBINDD_ERROR;
199         }
200
201         sid_to_string(state->response.data.sid.sid, &sid);
202         state->response.data.sid.type = SID_NAME_USER;
203
204         return WINBINDD_OK;
205 }
206
207 /* Convert a gid to a sid */
208
209 enum winbindd_result winbindd_gid_to_sid(struct winbindd_cli_state *state)
210 {
211         DOM_SID sid;
212
213         /* Bug out if the gid isn't in the winbind range */
214
215         if ((state->request.data.gid < server_state.gid_low) ||
216             (state->request.data.gid > server_state.gid_high)) {
217                 return WINBINDD_ERROR;
218         }
219
220         DEBUG(3, ("[%5d]: gid to sid %d\n", state->pid,
221                   state->request.data.gid));
222
223         /* Lookup sid for this uid */
224         if (NT_STATUS_IS_ERR(gid_to_sid(&sid, state->request.data.gid))) {
225                 DEBUG(1, ("Could not convert gid %d to sid\n",
226                           state->request.data.gid));
227                 return WINBINDD_ERROR;
228         }
229
230         /* Construct sid and return it */
231         sid_to_string(state->response.data.sid.sid, &sid);
232         state->response.data.sid.type = SID_NAME_DOM_GRP;
233
234         return WINBINDD_OK;
235 }