2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Luke Kenneth Caseson Leighton 1998-1999
7 Copyright (C) Jeremy Allison 1999
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 extern int DEBUGLEVEL
;
28 DOM_SID global_sam_sid
;
29 extern pstring global_myname
;
30 extern fstring global_myworkgroup
;
36 DOM_SID global_sid_Builtin
; /* local well-known domain */
37 DOM_SID global_sid_World_Domain
; /* everyone */
38 DOM_SID global_sid_World
; /* everyone */
39 DOM_SID global_sid_Creator_Owner_Domain
; /* Creator Owner */
40 DOM_SID global_sid_Creator_Owner
; /* Creator Owner */
41 DOM_SID global_sid_NT_Authority
; /* NT Authority */
42 DOM_SID global_sid_NULL
; /* NULL sid */
43 DOM_SID global_sid_Builtin_Guests
;
45 const DOM_SID
*global_sid_everyone
= &global_sid_World
;
47 typedef struct _known_sid_users
{
50 char *known_user_name
;
53 /* static known_sid_users no_users[] = {{0, 0, NULL}}; */
54 static known_sid_users everyone_users
[] = {{ 0, SID_NAME_WKN_GRP
, "Everyone" }, {0, 0, NULL
}};
55 static known_sid_users creator_owner_users
[] = {{ 0, SID_NAME_ALIAS
, "Creator Owner" }, {0, 0, NULL
}};
56 static known_sid_users nt_authority_users
[] = {
57 { 1, SID_NAME_ALIAS
, "Dialup" },
58 { 2, SID_NAME_ALIAS
, "Network"},
59 { 3, SID_NAME_ALIAS
, "Batch"},
60 { 4, SID_NAME_ALIAS
, "Interactive"},
61 { 6, SID_NAME_ALIAS
, "Service"},
62 { 7, SID_NAME_ALIAS
, "AnonymousLogon"},
63 { 8, SID_NAME_ALIAS
, "Proxy"},
64 { 9, SID_NAME_ALIAS
, "ServerLogon"},
65 { 11, SID_NAME_ALIAS
, "Authenticated Users"},
66 { 18, SID_NAME_ALIAS
, "SYSTEM"},
69 static struct sid_name_map_info
73 known_sid_users
*known_users
;
77 { &global_sam_sid
, global_myname
, NULL
},
78 { &global_sam_sid
, global_myworkgroup
, NULL
},
79 { &global_sid_Builtin
, "BUILTIN", NULL
},
80 { &global_sid_World_Domain
, "", &everyone_users
[0] },
81 { &global_sid_Creator_Owner_Domain
, "", &creator_owner_users
[0] },
82 { &global_sid_NT_Authority
, "NT Authority", &nt_authority_users
[0] },
86 /****************************************************************************
87 Creates some useful well known sids
88 ****************************************************************************/
90 void generate_wellknown_sids(void)
92 string_to_sid(&global_sid_Builtin
, "S-1-5-32");
93 string_to_sid(&global_sid_Builtin_Guests
, "S-1-5-32-546");
94 string_to_sid(&global_sid_World_Domain
, "S-1-1");
95 string_to_sid(&global_sid_World
, "S-1-1-0");
96 string_to_sid(&global_sid_Creator_Owner_Domain
, "S-1-3");
97 string_to_sid(&global_sid_Creator_Owner
, "S-1-3-0");
98 string_to_sid(&global_sid_NT_Authority
, "S-1-5");
99 string_to_sid(&global_sid_NULL
, "S-1-0-0");
102 /**************************************************************************
103 Turns a domain SID into a name, returned in the nt_domain argument.
104 ***************************************************************************/
106 BOOL
map_domain_sid_to_name(DOM_SID
*sid
, char *nt_domain
)
110 sid_to_string(sid_str
, sid
);
112 DEBUG(5,("map_domain_sid_to_name: %s\n", sid_str
));
114 if (nt_domain
== NULL
)
117 while (sid_name_map
[i
].sid
!= NULL
) {
118 sid_to_string(sid_str
, sid_name_map
[i
].sid
);
119 DEBUG(5,("map_domain_sid_to_name: compare: %s\n", sid_str
));
120 if (sid_equal(sid_name_map
[i
].sid
, sid
)) {
121 fstrcpy(nt_domain
, sid_name_map
[i
].name
);
122 DEBUG(5,("map_domain_sid_to_name: found '%s'\n", nt_domain
));
128 DEBUG(5,("map_domain_sid_to_name: mapping for %s not found\n", sid_str
));
133 /**************************************************************************
134 Looks up a known username from one of the known domains.
135 ***************************************************************************/
137 BOOL
lookup_known_rid(DOM_SID
*sid
, uint32 rid
, char *name
, uint8
*psid_name_use
)
140 struct sid_name_map_info
*psnm
;
142 for(i
= 0; sid_name_map
[i
].sid
!= NULL
; i
++) {
143 psnm
= &sid_name_map
[i
];
144 if(sid_equal(psnm
->sid
, sid
)) {
146 for(j
= 0; psnm
->known_users
&& psnm
->known_users
[j
].known_user_name
!= NULL
; j
++) {
147 if(rid
== psnm
->known_users
[j
].rid
) {
148 DEBUG(5,("lookup_builtin_rid: rid = %u, domain = '%s', user = '%s'\n",
149 (unsigned int)rid
, psnm
->name
, psnm
->known_users
[j
].known_user_name
));
150 fstrcpy( name
, psnm
->known_users
[j
].known_user_name
);
151 *psid_name_use
= psnm
->known_users
[j
].sid_name_use
;
161 /**************************************************************************
162 Turns a domain name into a SID.
163 *** side-effect: if the domain name is NULL, it is set to our domain ***
164 ***************************************************************************/
166 BOOL
map_domain_name_to_sid(DOM_SID
*sid
, char *nt_domain
)
170 if (nt_domain
== NULL
) {
171 DEBUG(5,("map_domain_name_to_sid: mapping NULL domain to our SID.\n"));
172 sid_copy(sid
, &global_sam_sid
);
176 if (nt_domain
[0] == 0) {
177 fstrcpy(nt_domain
, global_myname
);
178 DEBUG(5,("map_domain_name_to_sid: overriding blank name to %s\n", nt_domain
));
179 sid_copy(sid
, &global_sam_sid
);
183 DEBUG(5,("map_domain_name_to_sid: %s\n", nt_domain
));
185 while (sid_name_map
[i
].name
!= NULL
) {
186 DEBUG(5,("map_domain_name_to_sid: compare: %s\n", sid_name_map
[i
].name
));
187 if (strequal(sid_name_map
[i
].name
, nt_domain
)) {
189 sid_copy(sid
, sid_name_map
[i
].sid
);
190 sid_to_string(sid_str
, sid_name_map
[i
].sid
);
191 DEBUG(5,("map_domain_name_to_sid: found %s\n", sid_str
));
197 DEBUG(0,("map_domain_name_to_sid: mapping to %s not found.\n", nt_domain
));
201 /**************************************************************************
202 Splits a name of format \DOMAIN\name or name into its two components.
203 Sets the DOMAIN name to global_myname if it has not been specified.
204 ***************************************************************************/
206 void split_domain_name(const char *fullname
, char *domain
, char *name
)
211 *domain
= *name
= '\0';
213 if (fullname
[0] == '\\')
216 pstrcpy(full_name
, fullname
);
217 p
= strchr(full_name
+1, '\\');
221 fstrcpy(domain
, full_name
);
224 fstrcpy(domain
, global_myname
);
225 fstrcpy(name
, full_name
);
228 DEBUG(10,("split_domain_name:name '%s' split into domain :'%s' and user :'%s'\n",
229 fullname
, domain
, name
));
232 /*****************************************************************
233 Convert a SID to an ascii string.
234 *****************************************************************/
236 char *sid_to_string(fstring sidstr_out
, DOM_SID
*sid
)
240 /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
241 uint32 ia
= (sid
->id_auth
[5]) +
242 (sid
->id_auth
[4] << 8 ) +
243 (sid
->id_auth
[3] << 16) +
244 (sid
->id_auth
[2] << 24);
246 slprintf(sidstr_out
, sizeof(fstring
) - 1, "S-%u-%lu", (unsigned int)sid
->sid_rev_num
, (unsigned long)ia
);
248 for (i
= 0; i
< sid
->num_auths
; i
++) {
249 slprintf(subauth
, sizeof(subauth
)-1, "-%lu", (unsigned long)sid
->sub_auths
[i
]);
250 fstrcat(sidstr_out
, subauth
);
253 DEBUG(7,("sid_to_string returning %s\n", sidstr_out
));
257 /*****************************************************************
258 Convert a string to a SID. Returns True on success, False on fail.
259 *****************************************************************/
261 BOOL
string_to_sid(DOM_SID
*sidout
, char *sidstr
)
265 /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
268 memset((char *)sidout
, '\0', sizeof(DOM_SID
));
270 if (StrnCaseCmp( sidstr
, "S-", 2)) {
271 DEBUG(0,("string_to_sid: Sid %s does not start with 'S-'.\n", sidstr
));
276 if (!next_token(&p
, tok
, "-", sizeof(tok
))) {
277 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr
));
281 /* Get the revision number. */
282 sidout
->sid_rev_num
= (uint8
)strtoul(tok
, NULL
, 10);
284 if (!next_token(&p
, tok
, "-", sizeof(tok
))) {
285 DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr
));
289 /* identauth in decimal should be < 2^32 */
290 ia
= (uint32
)strtoul(tok
, NULL
, 10);
292 /* NOTE - the ia value is in big-endian format. */
293 sidout
->id_auth
[0] = 0;
294 sidout
->id_auth
[1] = 0;
295 sidout
->id_auth
[2] = (ia
& 0xff000000) >> 24;
296 sidout
->id_auth
[3] = (ia
& 0x00ff0000) >> 16;
297 sidout
->id_auth
[4] = (ia
& 0x0000ff00) >> 8;
298 sidout
->id_auth
[5] = (ia
& 0x000000ff);
300 sidout
->num_auths
= 0;
302 while(next_token(&p
, tok
, "-", sizeof(tok
)) &&
303 sidout
->num_auths
< MAXSUBAUTHS
) {
305 * NOTE - the subauths are in native machine-endian format. They
306 * are converted to little-endian when linearized onto the wire.
308 sid_append_rid(sidout
, (uint32
)strtoul(tok
, NULL
, 10));
311 DEBUG(7,("string_to_sid: converted SID %s ok\n", sidstr
));
316 /*****************************************************************
317 Add a rid to the end of a sid
318 *****************************************************************/
320 BOOL
sid_append_rid(DOM_SID
*sid
, uint32 rid
)
322 if (sid
->num_auths
< MAXSUBAUTHS
) {
323 sid
->sub_auths
[sid
->num_auths
++] = rid
;
329 /*****************************************************************
330 Removes the last rid from the end of a sid
331 *****************************************************************/
333 BOOL
sid_split_rid(DOM_SID
*sid
, uint32
*rid
)
335 if (sid
->num_auths
> 0) {
337 *rid
= sid
->sub_auths
[sid
->num_auths
];
343 /*****************************************************************
345 *****************************************************************/
347 void sid_copy(DOM_SID
*dst
, const DOM_SID
*src
)
351 memset((char *)dst
, '\0', sizeof(DOM_SID
));
353 dst
->sid_rev_num
= src
->sid_rev_num
;
354 dst
->num_auths
= src
->num_auths
;
356 memcpy(&dst
->id_auth
[0], &src
->id_auth
[0], sizeof(src
->id_auth
));
358 for (i
= 0; i
< src
->num_auths
; i
++)
359 dst
->sub_auths
[i
] = src
->sub_auths
[i
];
362 /*****************************************************************
363 Duplicates a sid - mallocs the target.
364 *****************************************************************/
366 DOM_SID
*sid_dup(DOM_SID
*src
)
373 if((dst
= malloc(sizeof(DOM_SID
))) != NULL
) {
374 memset(dst
, '\0', sizeof(DOM_SID
));
381 /*****************************************************************
382 Write a sid out into on-the-wire format.
383 *****************************************************************/
385 BOOL
sid_linearize(char *outbuf
, size_t len
, DOM_SID
*sid
)
389 if(len
< sid_size(sid
))
392 SCVAL(outbuf
,0,sid
->sid_rev_num
);
393 SCVAL(outbuf
,1,sid
->num_auths
);
394 memcpy(&outbuf
[2], sid
->id_auth
, 6);
395 for(i
= 0; i
< sid
->num_auths
; i
++)
396 SIVAL(outbuf
, 8 + (i
*4), sid
->sub_auths
[i
]);
401 /*****************************************************************
403 *****************************************************************/
405 BOOL
sid_equal(const DOM_SID
*sid1
, const DOM_SID
*sid2
)
409 if (sid1
== sid2
) return True
;
410 if (!sid1
|| !sid2
) return False
;
412 /* compare most likely different rids, first: i.e start at end */
413 for (i
= sid1
->num_auths
-1; i
>= 0; --i
)
414 if (sid1
->sub_auths
[i
] != sid2
->sub_auths
[i
])
417 if (sid1
->num_auths
!= sid2
->num_auths
)
419 if (sid1
->sid_rev_num
!= sid2
->sid_rev_num
)
422 for (i
= 0; i
< 6; i
++)
423 if (sid1
->id_auth
[i
] != sid2
->id_auth
[i
])
430 /*****************************************************************
431 Calculates size of a sid.
432 *****************************************************************/
434 size_t sid_size(DOM_SID
*sid
)
439 return sid
->num_auths
* sizeof(uint32
) + 8;