added jeremy's new c++-like code for parsing of security descriptors.
[samba.git] / source3 / lib / util_sid.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Samba utility functions
5    Copyright (C) Andrew Tridgell 1992-1998
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24
25 extern int DEBUGLEVEL;
26
27
28 /*****************************************************************
29  Convert a SID to an ascii string.
30 *****************************************************************/
31
32 char *sid_to_string(pstring sidstr_out, const DOM_SID *sid)
33 {
34   char subauth[16];
35   int i;
36   /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
37   uint32 ia = (sid->id_auth[5]) +
38               (sid->id_auth[4] << 8 ) +
39               (sid->id_auth[3] << 16) +
40               (sid->id_auth[2] << 24);
41
42   slprintf(sidstr_out, sizeof(pstring) - 1, "S-%u-%lu", (unsigned int)sid->sid_rev_num, (unsigned long)ia);
43
44   for (i = 0; i < sid->num_auths; i++)
45   {
46     slprintf(subauth, sizeof(subauth)-1, "-%lu", (unsigned long)sid->sub_auths[i]);
47     pstrcat(sidstr_out, subauth);
48   }
49
50   DEBUG(7,("sid_to_string returning %s\n", sidstr_out));
51   return sidstr_out;
52 }
53
54 /*****************************************************************
55  Convert a string to a SID. Returns True on success, False on fail.
56 *****************************************************************/  
57    
58 BOOL string_to_sid(DOM_SID *sidout, const char *sidstr)
59 {
60         const char *p = sidstr;
61         /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
62         uint32 ia;
63
64         memset((char *)sidout, '\0', sizeof(DOM_SID));
65
66         if (StrnCaseCmp( sidstr, "S-", 2))
67         {
68                 DEBUG(0,("string_to_sid: Sid %s does not start with 'S-'.\n", sidstr));
69                 return False;
70         }
71
72         if ((p = strchr(p, '-')) == NULL)
73         {
74                 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
75                 return False;
76         }
77
78         p++;
79
80         /* Get the revision number. */
81         sidout->sid_rev_num = (uint8)strtoul(p,NULL,10);
82
83         if ((p = strchr(p, '-')) == NULL)
84         {
85                 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
86                 return False;
87         }
88
89         p++;
90
91         /* identauth in decimal should be <  2^32 */
92         ia = (uint32)strtoul(p,NULL,10);
93
94         /* NOTE - the ia value is in big-endian format. */
95         sidout->id_auth[0] = 0;
96         sidout->id_auth[1] = 0;
97         sidout->id_auth[2] = (ia & 0xff000000) >> 24;
98         sidout->id_auth[3] = (ia & 0x00ff0000) >> 16;
99         sidout->id_auth[4] = (ia & 0x0000ff00) >> 8;
100         sidout->id_auth[5] = (ia & 0x000000ff);
101
102         sidout->num_auths = 0;
103
104         while (((p = strchr(p, '-')) != NULL) && sidout->num_auths < MAXSUBAUTHS)
105         {
106                 p++;
107                 /*
108                  * NOTE - the subauths are in native machine-endian format. They
109                  * are converted to little-endian when linearized onto the wire.
110                  */
111                 sid_append_rid(sidout, (uint32)strtoul(p, NULL, 10));
112         }
113
114         return True;
115 }
116
117 /*****************************************************************
118  add a rid to the end of a sid
119 *****************************************************************/  
120 BOOL sid_append_rid(DOM_SID *sid, uint32 rid)
121 {
122         if (sid->num_auths < MAXSUBAUTHS)
123         {
124                 sid->sub_auths[sid->num_auths++] = rid;
125                 return True;
126         }
127         return False;
128 }
129
130 /*****************************************************************
131  removes the last rid from the end of a sid
132 *****************************************************************/  
133 BOOL sid_split_rid(DOM_SID *sid, uint32 *rid)
134 {
135         if (sid->num_auths > 0)
136         {
137                 sid->num_auths--;
138                 if (rid != NULL)
139                 {
140                         (*rid) = sid->sub_auths[sid->num_auths];
141                 }
142                 return True;
143         }
144         return False;
145 }
146
147 /*****************************************************************
148  copies a sid
149 *****************************************************************/  
150 void sid_copy(DOM_SID *sid1, const DOM_SID *sid2)
151 {
152         int i;
153
154         for (i = 0; i < 6; i++)
155         {
156                 sid1->id_auth[i] = sid2->id_auth[i];
157         }
158
159         for (i = 0; i < sid2->num_auths; i++)
160         {
161                 sid1->sub_auths[i] = sid2->sub_auths[i];
162         }
163
164         sid1->num_auths   = sid2->num_auths;
165         sid1->sid_rev_num = sid2->sid_rev_num;
166 }
167
168 /*****************************************************************
169  compare two sids up to the auths of the first sid
170 *****************************************************************/  
171 BOOL sid_front_equal(const DOM_SID *sid1, const DOM_SID *sid2)
172 {
173         int i;
174
175         /* compare most likely different rids, first: i.e start at end */
176         for (i = sid1->num_auths-1; i >= 0; --i)
177         {
178                 if (sid1->sub_auths[i] != sid2->sub_auths[i]) return False;
179         }
180
181         if (sid1->num_auths   >  sid2->num_auths  ) return False;
182         if (sid1->sid_rev_num != sid2->sid_rev_num) return False;
183
184         for (i = 0; i < 6; i++)
185         {
186                 if (sid1->id_auth[i] != sid2->id_auth[i]) return False;
187         }
188
189         return True;
190 }
191
192 /*****************************************************************
193  compare two sids
194 *****************************************************************/  
195 BOOL sid_equal(const DOM_SID *sid1, const DOM_SID *sid2)
196 {
197         int i;
198
199         /* compare most likely different rids, first: i.e start at end */
200         for (i = sid1->num_auths-1; i >= 0; --i)
201         {
202                 if (sid1->sub_auths[i] != sid2->sub_auths[i]) return False;
203         }
204
205         if (sid1->num_auths   != sid2->num_auths  ) return False;
206         if (sid1->sid_rev_num != sid2->sid_rev_num) return False;
207
208         for (i = 0; i < 6; i++)
209         {
210                 if (sid1->id_auth[i] != sid2->id_auth[i]) return False;
211         }
212
213         return True;
214 }
215
216
217 /*****************************************************************
218  calculates size of a sid
219 *****************************************************************/  
220 int sid_size(const DOM_SID *sid)
221 {
222         if (sid == NULL)
223         {
224                 return 0;
225         }
226         return sid->num_auths * sizeof(uint32) + 8;
227 }
228
229
230 /*****************************************************************
231  Duplicates a sid - mallocs the target.
232 *****************************************************************/
233
234 DOM_SID *sid_dup(DOM_SID *src)
235 {
236   DOM_SID *dst;
237
238   if(!src)
239     return NULL;
240
241   if((dst = malloc(sizeof(DOM_SID))) != NULL) {
242        memset(dst, '\0', sizeof(DOM_SID));
243        sid_copy( dst, src);
244   }
245
246   return dst;
247 }