a193582387c679bc8a2b6514a104714d1b1c95a2
[samba.git] / source3 / utils / profiles.c
1 /*
2    Samba Unix/Linux SMB client utility profiles.c
3
4    Copyright (C) Richard Sharpe, <rsharpe@richardsharpe.com>   2002
5    Copyright (C) Jelmer Vernooij (conversion to popt)          2003
6    Copyright (C) Gerald (Jerry) Carter                         2005
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "system/filesys.h"
24 #include "popt_common.h"
25 #include "registry/reg_objects.h"
26 #include "registry/regfio.h"
27 #include "../libcli/security/security.h"
28
29 /* GLOBAL VARIABLES */
30
31 struct dom_sid old_sid, new_sid;
32 int change = 0, new_val = 0;
33 int opt_verbose = False;
34
35 /********************************************************************
36 ********************************************************************/
37
38 static void verbose_output(const char *format, ...) PRINTF_ATTRIBUTE(1,2);
39 static void verbose_output(const char *format, ...)
40 {
41         va_list args;
42         char *var = NULL;
43
44         if (!opt_verbose) {
45                 return;
46         }
47
48         va_start(args, format);
49         if ((vasprintf(&var, format, args)) == -1) {
50                 va_end(args);
51                 return;
52         }
53
54         fprintf(stdout, "%s", var);
55         va_end(args);
56         SAFE_FREE(var);
57 }
58
59 /********************************************************************
60 ********************************************************************/
61
62 static bool swap_sid_in_acl( struct security_descriptor *sd, struct dom_sid *s1, struct dom_sid *s2 )
63 {
64         struct security_acl *theacl;
65         int i;
66         bool update = False;
67
68         verbose_output("  Owner SID: %s\n", sid_string_tos(sd->owner_sid));
69         if ( dom_sid_equal( sd->owner_sid, s1 ) ) {
70                 sid_copy( sd->owner_sid, s2 );
71                 update = True;
72                 verbose_output("  New Owner SID: %s\n",
73                         sid_string_tos(sd->owner_sid));
74
75         }
76
77         verbose_output("  Group SID: %s\n", sid_string_tos(sd->group_sid));
78         if ( dom_sid_equal( sd->group_sid, s1 ) ) {
79                 sid_copy( sd->group_sid, s2 );
80                 update = True;
81                 verbose_output("  New Group SID: %s\n",
82                         sid_string_tos(sd->group_sid));
83         }
84
85         theacl = sd->dacl;
86         verbose_output("  DACL: %d entries:\n", theacl->num_aces);
87         for ( i=0; i<theacl->num_aces; i++ ) {
88                 verbose_output("    Trustee SID: %s\n",
89                         sid_string_tos(&theacl->aces[i].trustee));
90                 if ( dom_sid_equal( &theacl->aces[i].trustee, s1 ) ) {
91                         sid_copy( &theacl->aces[i].trustee, s2 );
92                         update = True;
93                         verbose_output("    New Trustee SID: %s\n",
94                                 sid_string_tos(&theacl->aces[i].trustee));
95                 }
96         }
97
98 #if 0
99         theacl = sd->sacl;
100         verbose_output("  SACL: %d entries: \n", theacl->num_aces);
101         for ( i=0; i<theacl->num_aces; i++ ) {
102                 verbose_output("    Trustee SID: %s\n",
103                         sid_string_tos(&theacl->aces[i].trustee));
104                 if ( dom_sid_equal( &theacl->aces[i].trustee, s1 ) ) {
105                         sid_copy( &theacl->aces[i].trustee, s2 );
106                         update = True;
107                         verbose_output("    New Trustee SID: %s\n",
108                                 sid_string_tos(&theacl->aces[i].trustee));
109                 }
110         }
111 #endif
112         return update;
113 }
114
115 /********************************************************************
116 ********************************************************************/
117
118 static bool copy_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
119                                 REGF_NK_REC *parent, REGF_FILE *outfile,
120                                 const char *parentpath  )
121 {
122         REGF_NK_REC *key, *subkey;
123         struct security_descriptor *new_sd;
124         struct regval_ctr *values;
125         struct regsubkey_ctr *subkeys;
126         int i;
127         char *path;
128         WERROR werr;
129
130         /* swap out the SIDs in the security descriptor */
131
132         if (nk->sec_desc->sec_desc == NULL) {
133                 new_sd = NULL;
134         } else {
135                 new_sd = security_descriptor_copy(outfile->mem_ctx,
136                                                   nk->sec_desc->sec_desc);
137         }
138         if (new_sd == NULL) {
139                 fprintf(stderr, "Failed to copy security descriptor!\n");
140                 return False;
141         }
142
143         verbose_output("ACL for %s%s%s\n", parentpath, parent ? "\\" : "", nk->keyname);
144         swap_sid_in_acl( new_sd, &old_sid, &new_sid );
145
146         werr = regsubkey_ctr_init(NULL, &subkeys);
147         if (!W_ERROR_IS_OK(werr)) {
148                 DEBUG(0,("copy_registry_tree: talloc() failure!\n"));
149                 return False;
150         }
151
152         werr = regval_ctr_init(subkeys, &values);
153         if (!W_ERROR_IS_OK(werr)) {
154                 TALLOC_FREE( subkeys );
155                 DEBUG(0,("copy_registry_tree: talloc() failure!\n"));
156                 return False;
157         }
158
159         /* copy values into the struct regval_ctr */
160
161         for ( i=0; i<nk->num_values; i++ ) {
162                 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
163                         nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
164         }
165
166         /* copy subkeys into the struct regsubkey_ctr */
167
168         while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
169                 regsubkey_ctr_addkey( subkeys, subkey->keyname );
170         }
171
172         key = regfio_write_key( outfile, nk->keyname, values, subkeys, new_sd, parent );
173
174         /* write each one of the subkeys out */
175
176         path = talloc_asprintf(subkeys, "%s%s%s",
177                         parentpath, parent ? "\\" : "",nk->keyname);
178         if (!path) {
179                 TALLOC_FREE( subkeys );
180                 return false;
181         }
182
183         nk->subkey_index = 0;
184         while ((subkey = regfio_fetch_subkey(infile, nk))) {
185                 if (!copy_registry_tree( infile, subkey, key, outfile, path)) {
186                         TALLOC_FREE(subkeys);
187                         return false;
188                 }
189         }
190
191         /* values is a talloc()'d child of subkeys here so just throw it all away */
192
193         TALLOC_FREE( subkeys );
194
195         verbose_output("[%s]\n", path);
196
197         return True;
198 }
199
200 /*********************************************************************
201 *********************************************************************/
202
203 int main( int argc, const char *argv[] )
204 {
205         TALLOC_CTX *frame = talloc_stackframe();
206         int opt;
207         REGF_FILE *infile, *outfile;
208         REGF_NK_REC *nk;
209         char *orig_filename, *new_filename;
210         struct poptOption long_options[] = {
211                 POPT_AUTOHELP
212                 { "change-sid", 'c', POPT_ARG_STRING, NULL, 'c', "Provides SID to change" },
213                 { "new-sid", 'n', POPT_ARG_STRING, NULL, 'n', "Provides SID to change to" },
214                 { "verbose", 'v', POPT_ARG_NONE, &opt_verbose, 'v', "Verbose output" },
215                 POPT_COMMON_SAMBA
216                 POPT_COMMON_VERSION
217                 POPT_TABLEEND
218         };
219         poptContext pc;
220
221         load_case_tables();
222
223         /* setup logging options */
224
225         setup_logging( "profiles", DEBUG_STDERR);
226
227         pc = poptGetContext("profiles", argc, argv, long_options,
228                 POPT_CONTEXT_KEEP_FIRST);
229
230         poptSetOtherOptionHelp(pc, "<profilefile>");
231
232         /* Now, process the arguments */
233
234         while ((opt = poptGetNextOpt(pc)) != -1) {
235                 switch (opt) {
236                 case 'c':
237                         change = 1;
238                         if (!string_to_sid(&old_sid, poptGetOptArg(pc))) {
239                                 fprintf(stderr, "Argument to -c should be a SID in form of S-1-5-...\n");
240                                 poptPrintUsage(pc, stderr, 0);
241                                 exit(254);
242                         }
243                         break;
244
245                 case 'n':
246                         new_val = 1;
247                         if (!string_to_sid(&new_sid, poptGetOptArg(pc))) {
248                                 fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n");
249                                 poptPrintUsage(pc, stderr, 0);
250                                 exit(253);
251                         }
252                         break;
253
254                 }
255         }
256
257         poptGetArg(pc);
258
259         if (!poptPeekArg(pc)) {
260                 poptPrintUsage(pc, stderr, 0);
261                 exit(1);
262         }
263
264         if ((!change && new_val) || (change && !new_val)) {
265                 fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n");
266                 poptPrintUsage(pc, stderr, 0);
267                 exit(252);
268         }
269
270         orig_filename = talloc_strdup(frame, poptPeekArg(pc));
271         if (!orig_filename) {
272                 exit(ENOMEM);
273         }
274         new_filename = talloc_asprintf(frame,
275                                         "%s.new",
276                                         orig_filename);
277         if (!new_filename) {
278                 exit(ENOMEM);
279         }
280
281         if (!(infile = regfio_open( orig_filename, O_RDONLY, 0))) {
282                 fprintf( stderr, "Failed to open %s!\n", orig_filename );
283                 fprintf( stderr, "Error was (%s)\n", strerror(errno) );
284                 exit (1);
285         }
286
287         if ( !(outfile = regfio_open( new_filename, (O_RDWR|O_CREAT|O_TRUNC),
288                                       (S_IRUSR|S_IWUSR) )) ) {
289                 fprintf( stderr, "Failed to open new file %s!\n", new_filename );
290                 fprintf( stderr, "Error was (%s)\n", strerror(errno) );
291                 exit (1);
292         }
293
294         /* actually do the update now */
295
296         if ((nk = regfio_rootkey( infile )) == NULL) {
297                 fprintf(stderr, "Could not get rootkey\n");
298                 exit(3);
299         }
300
301         if (!copy_registry_tree( infile, nk, NULL, outfile, "")) {
302                 fprintf(stderr, "Failed to write updated registry file!\n");
303                 exit(2);
304         }
305
306         /* cleanup */
307
308         regfio_close(infile);
309         regfio_close(outfile);
310
311         poptFreeContext(pc);
312
313         TALLOC_FREE(frame);
314         return 0;
315 }