talloc: Added doxygen config file.
[ira/wip.git] / lib / nss_wrapper / nss_wrapper.pl
1 #!/usr/bin/perl
2 #
3
4 use strict;
5
6 use Getopt::Long;
7 use Cwd qw(abs_path);
8
9 my $opt_help = 0;
10 my $opt_passwd_path = undef;
11 my $opt_group_path = undef;
12 my $opt_action = undef;
13 my $opt_type = undef;
14 my $opt_name = undef;
15 my $opt_member = undef;
16
17 my $passwdfn = undef;
18 my $groupfn = undef;
19 my $memberfn = undef;
20 my $actionfn = undef;
21
22 sub passwd_add($$$$);
23 sub passwd_delete($$$$);
24 sub group_add($$$$);
25 sub group_delete($$$$);
26 sub member_add($$$$);
27 sub member_delete($$$$);
28
29 sub check_path($$);
30
31 my $result = GetOptions(
32         'help|h|?'      => \$opt_help,
33         'passwd_path=s' => \$opt_passwd_path,
34         'group_path=s'  => \$opt_group_path,
35         'action=s'      => \$opt_action,
36         'type=s'        => \$opt_type,
37         'name=s'        => \$opt_name,
38         'member=s'      => \$opt_member
39 );
40
41 sub usage($;$)
42 {
43         my ($ret, $msg) = @_;
44
45         print $msg."\n\n" if defined($msg);
46
47         print "usage:
48
49         --help|-h|-?            Show this help.
50
51         --passwd_path <path>    Path of the 'passwd' file.
52         --group_path <path>     Path of the 'group' file.
53
54         --type <type>           'passwd', 'group' and 'member' are supported.
55
56         --action <action>       'add' or 'delete'.
57
58         --name <name>           The name of the object.
59
60         --member <member>       The name of the member.
61 ";
62         exit($ret);
63 }
64
65 usage(1) if (not $result);
66
67 usage(0) if ($opt_help);
68
69 if (not defined($opt_action)) {
70         usage(1, "missing: --action [add|delete]");
71 }
72 if ($opt_action eq "add") {
73         $passwdfn = \&passwd_add;
74         $groupfn = \&group_add;
75         $memberfn = \&member_add;
76 } elsif ($opt_action eq "delete") {
77         $passwdfn = \&passwd_delete;
78         $groupfn = \&group_delete;
79         $memberfn = \&member_delete;
80 } else {
81         usage(1, "invalid: --action [add|delete]: '$opt_action'");
82 }
83
84 if (not defined($opt_type)) {
85         usage(1, "missing: --type [passwd|group|member]");
86 }
87 if ($opt_type eq "member" and not defined($opt_member)) {
88         usage(1, "missing: --member <member>");
89 }
90 my $opt_fullpath_passwd;
91 my $opt_fullpath_group;
92 if ($opt_type eq "passwd") {
93         $actionfn = $passwdfn;
94         $opt_fullpath_passwd = check_path($opt_passwd_path, $opt_type);
95 } elsif ($opt_type eq "group") {
96         $actionfn = $groupfn;
97         $opt_fullpath_group = check_path($opt_group_path, $opt_type);
98 } elsif ($opt_type eq "member") {
99         $actionfn = $memberfn;
100         $opt_fullpath_passwd = check_path($opt_passwd_path, "passwd");
101         $opt_fullpath_group = check_path($opt_group_path, "group");
102 } else {
103         usage(1, "invalid: --type [passwd|group]: '$opt_type'")
104 }
105
106 if (not defined($opt_name)) {
107         usage(1, "missing: --name <name>");
108 }
109 if ($opt_name eq "") {
110         usage(1, "invalid: --name <name>");
111 }
112
113 exit $actionfn->($opt_fullpath_passwd, $opt_member, $opt_fullpath_group, $opt_name);
114
115 sub check_path($$)
116 {
117         my ($path,$type) = @_;
118
119         if (not defined($path)) {
120                 usage(1, "missing: --$type\_path <path>");
121         }
122         if ($path eq "" or $path eq "/") {
123                 usage(1, "invalid: --$type\_path <path>: '$path'");
124         }
125         my $fullpath = abs_path($path);
126         if (not defined($fullpath)) {
127                 usage(1, "invalid: --$type\_path <path>: '$path'");
128         }
129         return $fullpath;
130 }
131
132 sub passwd_add_entry($$);
133
134 sub passwd_load($)
135 {
136         my ($path) = @_;
137         my @lines;
138         my $passwd = undef;
139
140         open(PWD, "<$path") or die("Unable to open '$path' for read");
141         @lines = <PWD>;
142         close(PWD);
143
144         $passwd->{array} = ();
145         $passwd->{name} = {};
146         $passwd->{uid} = {};
147         $passwd->{path} = $path;
148
149         foreach my $line (@lines) {
150                 passwd_add_entry($passwd, $line);
151         }
152
153         return $passwd;
154 }
155
156 sub group_add_entry($$);
157
158 sub group_load($)
159 {
160         my ($path) = @_;
161         my @lines;
162         my $group = undef;
163
164         open(GROUP, "<$path") or die("Unable to open '$path' for read");
165         @lines = <GROUP>;
166         close(GROUP);
167
168         $group->{array} = ();
169         $group->{name} = {};
170         $group->{gid} = {};
171         $group->{path} = $path;
172
173         foreach my $line (@lines) {
174                 group_add_entry($group, $line);
175         }
176
177         return $group;
178 }
179
180 sub passwd_lookup_name($$)
181 {
182         my ($passwd, $name) = @_;
183
184         return undef unless defined($passwd->{name}{$name});
185
186         return $passwd->{name}{$name};
187 }
188
189 sub group_lookup_name($$)
190 {
191         my ($group, $name) = @_;
192
193         return undef unless defined($group->{name}{$name});
194
195         return $group->{name}{$name};
196 }
197
198 sub passwd_lookup_uid($$)
199 {
200         my ($passwd, $uid) = @_;
201
202         return undef unless defined($passwd->{uid}{$uid});
203
204         return $passwd->{uid}{$uid};
205 }
206
207 sub group_lookup_gid($$)
208 {
209         my ($group, $gid) = @_;
210
211         return undef unless defined($group->{gid}{$gid});
212
213         return $group->{gid}{$gid};
214 }
215
216 sub passwd_get_free_uid($)
217 {
218         my ($passwd) = @_;
219         my $uid = 1000;
220
221         while (passwd_lookup_uid($passwd, $uid)) {
222                 $uid++;
223         }
224
225         return $uid;
226 }
227
228 sub group_get_free_gid($)
229 {
230         my ($group) = @_;
231         my $gid = 1000;
232
233         while (group_lookup_gid($group, $gid)) {
234                 $gid++;
235         }
236
237         return $gid;
238 }
239
240 sub passwd_add_entry($$)
241 {
242         my ($passwd, $str) = @_;
243
244         chomp $str;
245         my @e = split(':', $str);
246
247         push(@{$passwd->{array}}, \@e);
248         $passwd->{name}{$e[0]} = \@e;
249         $passwd->{uid}{$e[2]} = \@e;
250 }
251
252 sub group_add_entry($$)
253 {
254         my ($group, $str) = @_;
255
256         chomp $str;
257         my @e = split(':', $str);
258
259         push(@{$group->{array}}, \@e);
260         $group->{name}{$e[0]} = \@e;
261         $group->{gid}{$e[2]} = \@e;
262 }
263
264 sub passwd_remove_entry($$)
265 {
266         my ($passwd, $eref) = @_;
267
268         for (my $i = 0; defined($passwd->{array}[$i]); $i++) {
269                 if ($eref == $passwd->{array}[$i]) {
270                         $passwd->{array}[$i] = undef;
271                 }
272         }
273
274         delete $passwd->{name}{${$eref}[0]};
275         delete $passwd->{uid}{${$eref}[2]};
276 }
277
278 sub group_remove_entry($$)
279 {
280         my ($group, $eref) = @_;
281
282         for (my $i = 0; defined($group->{array}[$i]); $i++) {
283                 if ($eref == $group->{array}[$i]) {
284                         $group->{array}[$i] = undef;
285                 }
286         }
287
288         delete $group->{name}{${$eref}[0]};
289         delete $group->{gid}{${$eref}[2]};
290 }
291
292 sub group_add_member($$$)
293 {
294         my ($group, $eref, $username) = @_;
295
296         my @members;
297         my $str = @$eref[3] || undef;
298         if ($str) {
299                 @members = split(",", $str);
300         }
301
302         foreach my $member (@members) {
303                 if ($member and $member eq $username) {
304                         die("account[$username] is already member of '@$eref[0]'");
305                 }
306         }
307
308         push(@members, $username);
309
310         my $gwent = @$eref[0].":x:".@$eref[2].":".join(",", @members);
311
312         group_remove_entry($group, $eref);
313
314         group_add_entry($group, $gwent);
315 }
316
317 sub group_delete_member($$$)
318 {
319         my ($group, $eref, $username) = @_;
320
321         my @members = undef;
322         my $str = @$eref[3] || undef;
323         if ($str) {
324                 @members = split(",", $str);
325         }
326         my @new_members;
327         my $removed = 0;
328
329         foreach my $member (@members) {
330                 if ($member and $member ne $username) {
331                         push(@new_members, $member);
332                 } else {
333                         $removed = 1;
334                 }
335         }
336
337         if ($removed != 1) {
338                 die("account[$username] is not member of '@$eref[0]'");
339         }
340
341         my $gwent = @$eref[0].":x:".@$eref[2].":".join(",", @new_members);
342
343         group_remove_entry($group, $eref);
344
345         group_add_entry($group, $gwent);
346 }
347
348 sub passwd_save($)
349 {
350         my ($passwd) = @_;
351         my @lines = ();
352         my $path = $passwd->{path};
353         my $tmppath = $path.$$;
354
355         foreach my $eref (@{$passwd->{array}}) {
356                 next unless defined($eref);
357
358                 my $line = join(':', @{$eref});
359                 push(@lines, $line);
360         }
361
362         open(PWD, ">$tmppath") or die("Unable to open '$tmppath' for write");
363         print PWD join("\n", @lines)."\n";
364         close(PWD);
365         rename($tmppath, $path) or die("Unable to rename $tmppath => $path");
366 }
367
368 sub group_save($)
369 {
370         my ($group) = @_;
371         my @lines = ();
372         my $path = $group->{path};
373         my $tmppath = $path.$$;
374
375         foreach my $eref (@{$group->{array}}) {
376                 next unless defined($eref);
377
378                 my $line = join(':', @{$eref});
379                 if (scalar(@{$eref}) == 3) {
380                         $line .= ":";
381                 }
382                 push(@lines, $line);
383         }
384
385         open(GROUP, ">$tmppath") or die("Unable to open '$tmppath' for write");
386         print GROUP join("\n", @lines)."\n";
387         close(GROUP);
388         rename($tmppath, $path) or die("Unable to rename $tmppath => $path");
389 }
390
391 sub passwd_add($$$$)
392 {
393         my ($path, $dummy, $dummy2, $name) = @_;
394
395         #print "passwd_add: '$name' in '$path'\n";
396
397         my $passwd = passwd_load($path);
398
399         my $e = passwd_lookup_name($passwd, $name);
400         die("account[$name] already exists in '$path'") if defined($e);
401
402         my $uid = passwd_get_free_uid($passwd);
403         my $gid = 65534;# nogroup gid
404
405         my $pwent = $name.":x:".$uid.":".$gid.":".$name." gecos:/nodir:/bin/false";
406
407         passwd_add_entry($passwd, $pwent);
408
409         passwd_save($passwd);
410
411         return 0;
412 }
413
414 sub passwd_delete($$$$)
415 {
416         my ($path, $dummy, $dummy2, $name) = @_;
417
418         #print "passwd_delete: '$name' in '$path'\n";
419
420         my $passwd = passwd_load($path);
421
422         my $e = passwd_lookup_name($passwd, $name);
423         die("account[$name] does not exists in '$path'") unless defined($e);
424
425         passwd_remove_entry($passwd, $e);
426
427         passwd_save($passwd);
428
429         return 0;
430 }
431
432 sub group_add($$$$)
433 {
434         my ($dummy, $dummy2, $path, $name) = @_;
435
436         #print "group_add: '$name' in '$path'\n";
437
438         my $group = group_load($path);
439
440         my $e = group_lookup_name($group, $name);
441         die("group[$name] already exists in '$path'") if defined($e);
442
443         my $gid = group_get_free_gid($group);
444
445         my $gwent = $name.":x:".$gid.":"."";
446
447         group_add_entry($group, $gwent);
448
449         group_save($group);
450
451         #printf("%d\n", $gid);
452
453         return 0;
454 }
455
456 sub group_delete($$$$)
457 {
458         my ($dummy, $dummy2, $path, $name) = @_;
459
460         #print "group_delete: '$name' in '$path'\n";
461
462         my $group = group_load($path);
463
464         my $e = group_lookup_name($group, $name);
465         die("group[$name] does not exists in '$path'") unless defined($e);
466
467         group_remove_entry($group, $e);
468
469         group_save($group);
470
471         return 0;
472 }
473
474 sub member_add($$$$)
475 {
476         my ($passwd_path, $username, $group_path, $groupname) = @_;
477
478         #print "member_add: adding '$username' in '$passwd_path' to '$groupname' in '$group_path'\n";
479
480         my $group = group_load($group_path);
481
482         my $g = group_lookup_name($group, $groupname);
483         die("group[$groupname] does not exists in '$group_path'") unless defined($g);
484
485         my $passwd = passwd_load($passwd_path);
486
487         my $u = passwd_lookup_name($passwd, $username);
488         die("account[$username] does not exists in '$passwd_path'") unless defined($u);
489
490         group_add_member($group, $g, $username);
491
492         group_save($group);
493
494         return 0;
495 }
496
497 sub member_delete($$$$)
498 {
499         my ($passwd_path, $username, $group_path, $groupname) = @_;
500
501         #print "member_delete: removing '$username' in '$passwd_path' from '$groupname' in '$group_path'\n";
502
503         my $group = group_load($group_path);
504
505         my $g = group_lookup_name($group, $groupname);
506         die("group[$groupname] does not exists in '$group_path'") unless defined($g);
507
508         my $passwd = passwd_load($passwd_path);
509
510         my $u = passwd_lookup_name($passwd, $username);
511         die("account[$username] does not exists in '$passwd_path'") unless defined($u);
512
513         group_delete_member($group, $g, $username);
514
515         group_save($group);
516
517         return 0;
518 }