| author | yippi |
| Mon, 27 Sep 2010 21:07:51 +0000 | |
| changeset 20108 | 51df67ca9307 |
| parent 20005 | 9cf65a2152fa |
| permissions | -rwxr-xr-x |
| 15698 | 1 |
diff -up system-tools-backends-1.4.2/users-conf.in.orig system-tools-backends-1.4.2/users-conf.in |
2 |
--- system-tools-backends-1.4.2/users-conf.in.orig 2009-05-01 14:59:26.685073313 +0100 |
|
3 |
+++ system-tools-backends-1.4.2/users-conf.in 2009-05-01 14:59:16.334547388 +0100 |
|
| 7860 | 4 |
@@ -47,6 +47,8 @@ |
5 |
# pw: modifying users/groups and user/group data on FreeBSD. |
|
6 |
||
7 |
||
8 |
+use Authen::PAM; |
|
9 |
+ |
|
10 |
BEGIN {
|
|
11 |
$SCRIPTSDIR = "@scriptsdir@"; |
|
12 |
if ($SCRIPTSDIR =~ /^@scriptsdir[@]/) |
|
| 15698 | 13 |
@@ -54,7 +56,8 @@ BEGIN {
|
14 |
$SCRIPTSDIR = "."; |
|
15 |
$DOTIN = ".in"; |
|
16 |
} |
|
17 |
- |
|
18 |
+ push(@INC, $SCRIPTSDIR); |
|
19 |
+ |
|
20 |
require "$SCRIPTSDIR/general.pl$DOTIN"; |
|
21 |
require "$SCRIPTSDIR/platform.pl$DOTIN"; |
|
22 |
require "$SCRIPTSDIR/util.pl$DOTIN"; |
|
23 |
@@ -63,6 +66,7 @@ BEGIN {
|
|
24 |
require "$SCRIPTSDIR/replace.pl$DOTIN"; |
|
25 |
} |
|
26 |
||
27 |
+use secdb; |
|
28 |
||
29 |
# --- Tool information --- # |
|
30 |
||
31 |
@@ -74,6 +78,7 @@ $version = "@VERSION@"; |
|
| 7860 | 32 |
"mandrake-7.1", "mandrake-7.2", "mandrake-9.0", "mandrake-9.1", "mandrake-9.2", |
33 |
"mandrake-10.0", "mandrake-10.1", |
|
34 |
"debian-2.2", "debian-3.0", "debian-sarge", |
|
35 |
+ "nexenta-1.0", "solaris-2.11", |
|
36 |
"suse-7.0", "suse-9.0", "suse-9.1", "turbolinux-7.0", |
|
37 |
"slackware-8.0.0", "slackware-8.1", "slackware-9.0.0", "slackware-9.1.0", "slackware-10.0.0", "slackware-10.1.0", "slackware-10.2.0", |
|
38 |
"freebsd-4", "freebsd-5", "freebsd-6", |
|
| 15698 | 39 |
@@ -93,6 +98,7 @@ end_of_description; |
| 8121 | 40 |
@passwd_names = ( "/etc/passwd" ); |
41 |
@shadow_names = ( "/etc/shadow", "/etc/master.passwd" ); |
|
42 |
@group_names = ( "/etc/group" ); |
|
43 |
+@rbac_names = ( "/etc/user_attr" ); # Files that will be changed by RBAC commands |
|
44 |
@login_defs_names = ( "/etc/login.defs", "/etc/adduser.conf" ); |
|
45 |
@shell_names = ( "/etc/shells" ); |
|
46 |
@skel_dir = ( "/usr/share/skel", "/etc/skel" ); |
|
| 15698 | 47 |
@@ -115,9 +121,33 @@ $cmd_pw = &gst_file_locate_tool ("
|
| 7860 | 48 |
# --- Mapping constants --- # |
49 |
||
50 |
%users_prop_map = (); |
|
51 |
+ |
|
52 |
+sub get_users_prop_array |
|
53 |
+{
|
|
54 |
@users_prop_array = (); |
|
55 |
||
56 |
-if ($$tool{"platform"} eq "Linux")
|
|
| 8436 | 57 |
+if ($$tool{"system"} eq "Linux")
|
58 |
+{
|
|
59 |
+ @users_prop_array = ( |
|
60 |
+ "key", 0, |
|
61 |
+ "login", 1, |
|
62 |
+ "password", 2, |
|
63 |
+ "uid", 3, |
|
64 |
+ "gid", 4, |
|
65 |
+ "comment", 5, |
|
66 |
+ "home", 6, |
|
67 |
+ "shell", 7, |
|
68 |
+ "last_mod", 8, # Read shadow (5) for these. |
|
69 |
+ "passwd_min_life", 9, |
|
70 |
+ "passwd_max_life", 10, |
|
71 |
+ "passwd_exp_warn", 11, |
|
72 |
+ "passwd_exp_disable", 12, |
|
73 |
+ "passwd_disable", 13, |
|
74 |
+ "reserved", 14, |
|
75 |
+ "is_shadow", 15, |
|
| 15698 | 76 |
+ "", ""); |
77 |
+} |
|
78 |
+if ($$tool{"system"} eq "SunOS")
|
|
79 |
{
|
|
80 |
@users_prop_array = ( |
|
81 |
"key", 0, |
|
82 |
@@ -136,6 +166,8 @@ if ($$tool{"platform"} eq "Linux")
|
|
83 |
"passwd_disable", 13, |
|
84 |
"reserved", 14, |
|
85 |
"is_shadow", 15, |
|
| 11320 | 86 |
+ "rbac", 16, |
| 13240 | 87 |
+ "role", 17, |
| 15698 | 88 |
"", ""); |
89 |
} |
|
| 11320 | 90 |
else |
| 15698 | 91 |
@@ -157,6 +189,7 @@ for ($i = 0; $users_prop_array[$i] ne "" |
| 7860 | 92 |
$users_prop_map {$users_prop_array[$i]} = $users_prop_array[$i + 1];
|
93 |
$users_prop_map {$users_prop_array[$i + 1]} = $users_prop_array[$i];
|
|
94 |
} |
|
95 |
+} |
|
96 |
||
97 |
%groups_prop_map = (); |
|
98 |
@groups_prop_array = ( |
|
| 15698 | 99 |
@@ -193,6 +226,71 @@ for ($i = 0; $groups_prop_array[$i] ne " |
| 8121 | 100 |
%login_defs_prop_map = (); |
101 |
%profiles_prop_map = (); |
|
102 |
||
103 |
+sub read_rbac() {
|
|
104 |
+ return unless ( $gst_dist =~ /^solaris/ ); |
|
105 |
+ |
|
106 |
+ my ($hash) = @_; |
|
107 |
+ my ($buffer, $line, $profile, $description, $dummy); |
|
| 13240 | 108 |
+ my ($user, $attr); |
109 |
+ my (%rbac, %rbac_profiles, %role, %rbac_roles); |
|
| 8121 | 110 |
+ |
111 |
+ %rbac=(); |
|
112 |
+ %rbac_profiles=(); |
|
| 13240 | 113 |
+ %rbac_roles=(); |
| 8121 | 114 |
+ |
| 15698 | 115 |
+ # Get Profiles |
116 |
+ secdb::setprofattr(); |
|
117 |
+ while ( $pattr = secdb::getprofattr() ) {
|
|
118 |
+ $profile = $pattr->{name};
|
|
119 |
+ $description = $pattr->{desc};
|
|
120 |
+ # Skip the "All" special profile. |
|
121 |
+ next if ( $profile =~ /^All$/ ); |
|
122 |
+ |
|
| 8121 | 123 |
+ $rbac_profiles{$profile} = &gst_xml_quote($description);
|
124 |
+ } |
|
| 15698 | 125 |
+ secdb::endprofattr(); |
| 8121 | 126 |
+ |
127 |
+ $rbac{"rbac_profiles"} = \%rbac_profiles;
|
|
128 |
+ |
|
129 |
+ $$hash{"rbacdb"} = \%rbac;
|
|
| 13240 | 130 |
+ |
| 15698 | 131 |
+ # Get Roles |
132 |
+ secdb::setuserattr(); |
|
133 |
+ while ( $uattr = secdb::getuserattr() ) {
|
|
134 |
+ $user = $uattr->{name};
|
|
135 |
+ $type = secdb::kva_match($uattr->{attr}, $secdb::USERATTR_TYPE_KW );
|
|
136 |
+ if ( $type =~ $secdb::USERATTR_TYPE_ROLE ) {
|
|
137 |
+ $rbac_roles{$user} = &gst_xml_quote($user)
|
|
138 |
+ } |
|
| 13240 | 139 |
+ } |
| 15698 | 140 |
+ secdb::enduserattr(); |
| 13240 | 141 |
+ |
142 |
+ $role{"rbac_roles"} = \%rbac_roles;
|
|
143 |
+ |
|
144 |
+ $$hash{"roledb"} = \%role;
|
|
| 8121 | 145 |
+} |
146 |
+ |
|
| 11808 | 147 |
+sub read_rbac_default_profiles |
148 |
+{
|
|
149 |
+ return unless ( $gst_dist =~ /^solaris/ ); |
|
150 |
+ |
|
151 |
+ my ($buffer, $line, $dummy, @def_prof, $def_prof_ref); |
|
152 |
+ $buffer = &gst_file_buffer_load("/etc/security/policy.conf");
|
|
153 |
+ foreach $line ( @$buffer ) {
|
|
154 |
+ chomp $line; |
|
155 |
+ if ( $line =~ /^PROFS_GRANTED=/ ) |
|
156 |
+ {
|
|
157 |
+ ($dummy, $def_line) = split(/=/, $line, 2); |
|
158 |
+ @def_prof = split (/,/, $def_line); |
|
159 |
+ foreach ( @def_prof ) {
|
|
160 |
+ $def_prof_ref->{$_} = 1;
|
|
161 |
+ } |
|
162 |
+ return $def_prof_ref; |
|
163 |
+ } |
|
164 |
+ next; |
|
165 |
+ } |
|
166 |
+} |
|
167 |
+ |
|
| 8121 | 168 |
sub get_login_defs_prop_array |
169 |
{
|
|
170 |
my @prop_array; |
|
| 15698 | 171 |
@@ -315,6 +413,30 @@ sub get_profiles_prop_array |
| 7860 | 172 |
} |
173 |
} |
|
174 |
||
175 |
+my $nexenta_logindefs_defaults = {
|
|
176 |
+ 'login_defs' => 0, # Open Solaris doesn't have a login.defs file. |
|
177 |
+ 'shell' => '/bin/bash', |
|
178 |
+ 'group' => 'users', |
|
179 |
+ 'skel_dir' => '/etc/skel/', |
|
180 |
+ 'home_prefix' => '/export/home/$user', |
|
181 |
+ 'gmin' => 1000, |
|
182 |
+ 'gmax' => 2147483647, # Based on MAXUID from sys/param.h |
|
|
10303
cf9f0c6127b2
* patches/system-tools-backend-08-users.diff : Bug : 6591890, change
mattman
parents:
9165
diff
changeset
|
183 |
+ 'umin' => 100, |
| 7860 | 184 |
+ 'umax' => 2147483647, # Based on MAXUID from sys/param.h |
185 |
+}; |
|
186 |
+ |
|
187 |
+my $solaris_logindefs_defaults = {
|
|
188 |
+ 'login_defs' => 0, # Open Solaris doesn't have a login.defs file. |
|
189 |
+ 'shell' => '/bin/bash', |
|
190 |
+ 'group' => 'users', |
|
191 |
+ 'skel_dir' => '/etc/skel/', |
|
| 8847 | 192 |
+ 'home_prefix' => '/export/home/$user', |
| 7860 | 193 |
+ 'gmin' => 1000, |
194 |
+ 'gmax' => 2147483647, # Based on MAXUID from sys/param.h |
|
|
10303
cf9f0c6127b2
* patches/system-tools-backend-08-users.diff : Bug : 6591890, change
mattman
parents:
9165
diff
changeset
|
195 |
+ 'umin' => 100, |
| 7860 | 196 |
+ 'umax' => 2147483647, # Based on MAXUID from sys/param.h |
197 |
+}; |
|
198 |
+ |
|
199 |
my $rh_logindefs_defaults = {
|
|
200 |
'shell' => '/bin/bash', |
|
201 |
'group' => '$user', |
|
| 15698 | 202 |
@@ -362,6 +484,8 @@ my $logindefs_dist_map = {
|
| 7860 | 203 |
'debian-2.2' => $rh_logindefs_defaults, |
204 |
'debian-3.0' => $rh_logindefs_defaults, |
|
205 |
'debian-sarge' => $rh_logindefs_defaults, |
|
206 |
+ 'nexenta-1.0' => $nexenta_logindefs_defaults, |
|
207 |
+ 'solaris-2.11' => $solaris_logindefs_defaults, |
|
208 |
'vine-3.0' => $rh_logindefs_defaults, |
|
209 |
'vine-3.1' => $rh_logindefs_defaults, |
|
210 |
'gentoo' => $gentoo_logindefs_defaults, |
|
| 15698 | 211 |
@@ -419,7 +543,8 @@ sub arr_cmp_recurse |
| 8436 | 212 |
my ($a1, $a2) = @_; |
213 |
my $i; |
|
214 |
||
215 |
- return -1 if ($#$a1 != $#$a2); |
|
216 |
+ return 0 if ( ( $#$a1 < 0 || $#$a2 < 0 ) && $#$a1 == $#$a2 ); |
|
217 |
+ return -1 if ($#$a1 != $#$a2 || $#$a1 < 0 || $#$a2 < 0 ); |
|
218 |
||
219 |
for ($i = 0; $i <= $#$a1; $i++) {
|
|
220 |
if (ref ($$a1[$i]) eq "ARRAY") { # see if this is a reference.
|
|
| 15698 | 221 |
@@ -453,6 +578,7 @@ sub read |
| 8121 | 222 |
&read_passwd_shadow (\%hash); |
223 |
&read_profiledb (\%hash); |
|
224 |
&read_shells (\%hash); |
|
225 |
+ &read_rbac (\%hash) if ( $gst_dist =~ /^solaris/); |
|
226 |
||
227 |
return \%hash; |
|
228 |
} |
|
| 15698 | 229 |
@@ -553,11 +679,11 @@ sub read_logindefs |
| 7860 | 230 |
} |
231 |
else |
|
232 |
{
|
|
233 |
- # Put safe defaults for distros/OS that don't have any defaults file |
|
234 |
- $logindefs->{"umin"} = '1000';
|
|
235 |
- $logindefs->{"umax"} = '60000';
|
|
236 |
- $logindefs->{"gmin"} = '1000';
|
|
237 |
- $logindefs->{"gmax"} = '60000';
|
|
238 |
+ # Put safe defaults for distros/OS that don't have any defaults set |
|
239 |
+ $logindefs->{"umin"} = '1000' unless ($logindefs->{"umin"});
|
|
240 |
+ $logindefs->{"umax"} = '60000' unless ($logindefs->{"umax"});
|
|
241 |
+ $logindefs->{"gmin"} = '1000' unless ($logindefs->{"gmin"});
|
|
242 |
+ $logindefs->{"gmax"} = '60000' unless ($logindefs->{"gmax"});
|
|
243 |
} |
|
244 |
} |
|
245 |
||
| 15698 | 246 |
@@ -602,6 +728,7 @@ sub read_passwd_shadow |
| 8121 | 247 |
my ($ifh, @users, %users_hash, $passwd_last_modified); |
248 |
my (@line, $copy, %tmphash); |
|
249 |
my $login_pos = $users_prop_map{"login"};
|
|
| 8436 | 250 |
+ #my (%users_rbac_profiles); |
| 8121 | 251 |
my $i = 0; |
252 |
||
253 |
# Find the passwd file. |
|
| 15698 | 254 |
@@ -660,6 +787,35 @@ sub read_passwd_shadow |
| 8121 | 255 |
|
256 |
&gst_file_close ($ifh); |
|
257 |
} |
|
258 |
+ if ($gst_dist =~ /^solaris/ ) {
|
|
| 8436 | 259 |
+ my $rbac_pos = $users_prop_map{"rbac"};
|
| 13240 | 260 |
+ my $role_pos = $users_prop_map{"role"};
|
| 8121 | 261 |
+ my ($fd); |
262 |
+ foreach $user (@users) {
|
|
263 |
+ my @profiles; |
|
| 13240 | 264 |
+ my @roles, $tmproles; |
| 8121 | 265 |
+ my $logname = $$user[1]; |
| 15698 | 266 |
+ |
267 |
+ # Get User's Profiles |
|
| 15693 | 268 |
+ @profiles = (); |
| 15698 | 269 |
+ if ( $uattr = secdb::getusernam( $logname ) ) {
|
270 |
+ $prof_str = secdb::kva_match($uattr->{attr}, $secdb::USERATTR_PROFILES_KW);
|
|
271 |
+ @profiles = split(/,/, $prof_str ); |
|
272 |
+ chomp( @profiles ); |
|
273 |
+ } |
|
| 8436 | 274 |
+ @{$tmphash{$logname}}[$rbac_pos] = \@profiles;
|
| 15698 | 275 |
+ # Get User's Roles |
276 |
+ @roles = (); |
|
277 |
+ if ( $uattr = secdb::getusernam( $logname ) ) {
|
|
278 |
+ $roles_str = secdb::kva_match($uattr->{attr}, $secdb::USERATTR_ROLES_KW);
|
|
279 |
+ @roles = split(/,/, $roles_str ); |
|
280 |
+ chomp( @roles ); |
|
281 |
+ } |
|
| 13240 | 282 |
+ @{$tmphash{$logname}}[$role_pos] = \@roles;
|
| 15698 | 283 |
+ |
| 8121 | 284 |
+ } |
| 8436 | 285 |
+ #$$hash{"users_rbac_profiles"} = \%users_rbac_profiles;
|
| 8121 | 286 |
+ } |
| 15698 | 287 |
|
| 8121 | 288 |
$$hash{"users"} = \@users;
|
289 |
$$hash{"users_hash"} = \%users_hash;
|
|
| 15698 | 290 |
@@ -740,7 +896,40 @@ sub read_shells |
| 7860 | 291 |
push (@shells, "/bin/false") if (stat ("/bin/false"));
|
292 |
||
293 |
$ifh = &gst_file_open_read_from_names(@shell_names); |
|
294 |
- return unless $ifh; |
|
295 |
+ unless ($ifh) |
|
296 |
+ {
|
|
297 |
+ if ($gst_dist =~ /solaris/) |
|
298 |
+ {
|
|
| 14599 | 299 |
+ push (@shells, "/bin/bash") if (stat ("/bin/bash"));
|
300 |
+ push (@shells, "/bin/csh") if (stat ("/bin/csh"));
|
|
301 |
+ push (@shells, "/bin/jsh") if (stat ("/bin/jsh"));
|
|
302 |
+ push (@shells, "/bin/ksh") if (stat ("/bin/ksh"));
|
|
303 |
+ push (@shells, "/bin/pfcsh") if (stat ("/bin/pfcsh"));
|
|
304 |
+ push (@shells, "/bin/pfksh") if (stat ("/bin/pfksh"));
|
|
305 |
+ push (@shells, "/bin/pfsh") if (stat ("/bin/pfsh"));
|
|
306 |
+ push (@shells, "/bin/sh") if (stat ("/bin/sh"));
|
|
307 |
+ push (@shells, "/bin/tcsh") if (stat ("/bin/tcsh"));
|
|
308 |
+ push (@shells, "/bin/zsh") if (stat ("/bin/zsh"));
|
|
309 |
+ push (@shells, "/bin/jsh") if (stat ("/bin/jsh"));
|
|
310 |
+ push (@shells, "/sbin/jsh") if (stat ("/sbin/jsh"));
|
|
311 |
+ push (@shells, "/sbin/pfsh") if (stat ("/sbin/pfsh"));
|
|
312 |
+ push (@shells, "/sbin/sh") if (stat ("/sbin/sh"));
|
|
313 |
+ push (@shells, "/usr/bin/bash") if (stat ("/usr/bin/bash"));
|
|
314 |
+ push (@shells, "/usr/bin/csh") if (stat ("/usr/bin/csh"));
|
|
315 |
+ push (@shells, "/usr/bin/jsh") if (stat ("/usr/bin/jsh"));
|
|
316 |
+ push (@shells, "/usr/bin/ksh") if (stat ("/usr/bin/ksh"));
|
|
317 |
+ push (@shells, "/usr/bin/pfcsh") if (stat ("/usr/bin/pfcsh"));
|
|
318 |
+ push (@shells, "/usr/bin/pfksh") if (stat ("/usr/bin/pfksh"));
|
|
319 |
+ push (@shells, "/usr/bin/pfsh") if (stat ("/usr/bin/pfsh"));
|
|
320 |
+ push (@shells, "/usr/bin/sh") if (stat ("/usr/bin/sh"));
|
|
321 |
+ push (@shells, "/usr/bin/tcsh") if (stat ("/usr/bin/tcsh"));
|
|
322 |
+ push (@shells, "/usr/bin/zsh") if (stat ("/usr/bin/zsh"));
|
|
323 |
+ push (@shells, "/usr/xpg4/bin/sh") if (stat ("/usr/xpg4/bin/sh"));
|
|
| 7860 | 324 |
+ $$hash{"shelldb"} = \@shells;
|
325 |
+ } |
|
326 |
+ return; |
|
327 |
+ } |
|
328 |
+ |
|
329 |
||
330 |
while (<$ifh>) |
|
331 |
{
|
|
| 15698 | 332 |
@@ -879,6 +1068,11 @@ sub change_user_chfn |
| 7860 | 333 |
{
|
334 |
$command = "$cmd_pw usermod -n " . $username . " -c \'" . $comment . "\'"; |
|
335 |
} |
|
336 |
+ elsif ($gst_dist =~ /^solaris/) |
|
337 |
+ {
|
|
338 |
+ ($fname, $office, $office_phone, $home_phone) = @line; |
|
339 |
+ $command = "$cmd_usermod" . " -c \'" . $fname . "\' " . $username; |
|
340 |
+ } |
|
341 |
else |
|
342 |
{
|
|
343 |
($fname, $office, $office_phone, $home_phone) = @line; |
|
| 15698 | 344 |
@@ -886,7 +1080,7 @@ sub change_user_chfn |
| 7860 | 345 |
$fname = "-f \'" . $fname . "\'"; |
346 |
$home_phone = "-h \'" . $home_phone . "\'"; |
|
347 |
||
348 |
- if ($gst_dist =~ /^debian/ || $gst_dist =~ /^archlinux/) |
|
349 |
+ if ($gst_dist =~ /^debian/ || $gst_dist =~ /^archlinux/ || $gst_dist =~ /^nexenta/) |
|
350 |
{
|
|
351 |
$office = "-r \'" . $office . "\'"; |
|
352 |
$office_phone = "-w \'" . $office_phone . "\'"; |
|
| 15698 | 353 |
@@ -903,6 +1097,30 @@ sub change_user_chfn |
| 7860 | 354 |
&gst_file_run ($command); |
355 |
} |
|
356 |
||
357 |
+$service = "passwd"; |
|
358 |
+$username = ""; |
|
359 |
+$newpassword = ""; |
|
360 |
+ |
|
361 |
+sub my_conv_func {
|
|
362 |
+ my @res; |
|
363 |
+ while ( @_ ) {
|
|
364 |
+ my $code = shift; |
|
365 |
+ my $msg = shift; |
|
366 |
+ my $ans = ""; |
|
367 |
+ |
|
368 |
+ $ans = $username if ($code == PAM_PROMPT_ECHO_ON() ); |
|
369 |
+ if ($code == PAM_PROMPT_ECHO_OFF() ) {
|
|
370 |
+ $ans = $newpassword; |
|
371 |
+ $ans = $newpassword; |
|
372 |
+ |
|
373 |
+ } |
|
374 |
+ |
|
375 |
+ push @res, (PAM_SUCCESS(),$ans); |
|
376 |
+ } |
|
377 |
+ push @res, PAM_SUCCESS(); |
|
378 |
+ return @res; |
|
379 |
+} |
|
380 |
+ |
|
381 |
sub add_user |
|
382 |
{
|
|
383 |
my ($data) = @_; |
|
| 15698 | 384 |
@@ -932,6 +1150,69 @@ sub add_user |
| 7860 | 385 |
print $pwdpipe $$data[$users_prop_map{"password"}];
|
386 |
&gst_file_close ($pwdpipe); |
|
387 |
} |
|
388 |
+ elsif ($gst_dist =~ /^nexenta/) |
|
389 |
+ {
|
|
390 |
+ my $pwdpipe; |
|
391 |
+ $home_parents = $$data[$users_prop_map{"home"}];
|
|
392 |
+ $home_parents =~ s/\/+[^\/]+\/*$//; |
|
393 |
+ &gst_file_run ("$tool_mkdir -p $home_parents");
|
|
394 |
+ |
|
395 |
+ $command = "$cmd_useradd" . " -d \'" . $$data[$users_prop_map{"home"}] .
|
|
396 |
+ "\' -g \'" . $$data[$users_prop_map{"gid"}] .
|
|
397 |
+ "\' -s \'" . $$data[$users_prop_map{"shell"}] .
|
|
398 |
+ "\' -u \'" . $$data[$users_prop_map{"uid"}] .
|
|
399 |
+ "\' \'" . $$data[$users_prop_map{"login"}] . "\'";
|
|
400 |
+ &gst_file_run ($command); |
|
401 |
+ &gst_file_run("echo " . $$data[$users_prop_map{"login"}] . ":" . $$data[$users_prop_map{"password"}] . " | chpasswd -e");
|
|
402 |
+ } |
|
403 |
+ elsif ($gst_dist =~ /^solaris/) |
|
404 |
+ {
|
|
405 |
+ $home_parents = $$data[$users_prop_map{"home"}];
|
|
406 |
+ $home_parents =~ s/\/+[^\/]+\/*$//; |
|
407 |
+ &gst_file_run ("$tool_mkdir -p $home_parents");
|
|
408 |
+ |
|
| 9165 | 409 |
+ $command = "$cmd_useradd"; |
410 |
+ if ($$data[$users_prop_map{"rbac"}] ne undef ) {
|
|
411 |
+ my (@profiles, $old_user_profiles, $new_user_profiles ); |
|
412 |
+ $new_user_profiles = $$data[$users_prop_map{"rbac"}];
|
|
413 |
+ @profiles = (); |
|
414 |
+ push( @profiles, @$new_user_profiles ); |
|
415 |
+ if ( $#profiles >= 0 ) {
|
|
416 |
+ my $profiles_str = ""; |
|
417 |
+ foreach ( @profiles ) {
|
|
418 |
+ $profiles_str .= ',' unless ( $profiles_str eq "" ); |
|
419 |
+ $profiles_str .= $_; |
|
420 |
+ } |
|
421 |
+ $command .= " -P \'" . $profiles_str . "\'"; |
|
422 |
+ } |
|
423 |
+ } |
|
424 |
+ |
|
| 15693 | 425 |
+ if ($$data[$users_prop_map{"role"}] ne undef ) {
|
426 |
+ my (@roles, $old_user_roles, $new_user_roles ); |
|
427 |
+ $new_user_roles = $$data[$users_prop_map{"role"}];
|
|
428 |
+ @roles = (); |
|
429 |
+ push( @roles, @$new_user_roles ); |
|
430 |
+ if ( $#roles >= 0 ) {
|
|
431 |
+ my $roles_str = ""; |
|
432 |
+ foreach ( @roles ) {
|
|
433 |
+ $roles_str .= ',' unless ( $roles_str eq "" ); |
|
434 |
+ $roles_str .= $_; |
|
435 |
+ } |
|
436 |
+ $command .= " -R \'" . $roles_str . "\'"; |
|
437 |
+ } |
|
438 |
+ } |
|
439 |
+ |
|
| 9165 | 440 |
+ $command .= " -d \'" . $$data[$users_prop_map{"home"}] .
|
| 7860 | 441 |
+ "\' -g \'" . $$data[$users_prop_map{"gid"}] .
|
442 |
+ "\' -m -s \'" . $$data[$users_prop_map{"shell"}] .
|
|
443 |
+ "\' -u \'" . $$data[$users_prop_map{"uid"}] .
|
|
444 |
+ "\' \'" . $$data[$users_prop_map{"login"}] . "\'";
|
|
445 |
+ &gst_file_run ($command); |
|
446 |
+ $username = $$data[$users_prop_map{"login"}];
|
|
447 |
+ $newpassword = $$data[$users_prop_map{"password"}];
|
|
448 |
+ ref($pamh = new Authen::PAM($service, $username, \&my_conv_func)); |
|
449 |
+ $pamh->pam_chauthtok(PAM_NO_AUTHTOK_CHECK()); |
|
450 |
+ } |
|
451 |
else |
|
452 |
{
|
|
453 |
$home_parents = $$data[$users_prop_map{"home"}];
|
|
| 15698 | 454 |
@@ -967,9 +1248,138 @@ sub change_user |
| 7860 | 455 |
" -H 0"; # pw(8) reads password from STDIN |
456 |
||
457 |
$pwdpipe = &gst_file_run_pipe($command, $GST_FILE_WRITE); |
|
458 |
- print $pwdpipe $$data[$users_prop_map{"password"}];
|
|
459 |
+ print $pwdpipe $$new_data[$users_prop_map{"password"}];
|
|
460 |
&gst_file_close ($pwdpipe); |
|
461 |
} |
|
462 |
+ elsif ($gst_dist =~ /^nexenta/) |
|
463 |
+ {
|
|
464 |
+ $command = "$cmd_usermod" . " -d \'" . $$new_data[$users_prop_map{"home"}] .
|
|
465 |
+ "\' -g \'" . $$new_data[$users_prop_map{"gid"}] .
|
|
466 |
+ "\' -l \'" . $$new_data[$users_prop_map{"login"}] .
|
|
467 |
+ "\' -s \'" . $$new_data[$users_prop_map{"shell"}] .
|
|
468 |
+ "\' -u \'" . $$new_data[$users_prop_map{"uid"}] .
|
|
469 |
+ "\' \'" . $$old_data[$users_prop_map{"login"}] . "\'";
|
|
470 |
+ &gst_file_run ($command); |
|
471 |
+ &gst_file_run("echo " . $$new_data[$users_prop_map{"login"}] . ":" . $$new_data[$users_prop_map{"password"}] . " | chpasswd -e");
|
|
472 |
+ } |
|
473 |
+ elsif ($gst_dist =~ /^solaris/) |
|
474 |
+ {
|
|
475 |
+ $command = "$cmd_usermod" ; |
|
476 |
+ |
|
477 |
+ $command .= " -u \'" . $$new_data[$users_prop_map{"uid"}] . "\'"
|
|
478 |
+ if ( $$new_data[$users_prop_map{"uid"}] ne $$old_data[$users_prop_map{"uid"}] );
|
|
479 |
+ $command .= " -g \'" . $$new_data[$users_prop_map{"gid"}] . "\'"
|
|
480 |
+ if ( $$new_data[$users_prop_map{"gid"}] ne $$old_data[$users_prop_map{"gid"}] );
|
|
481 |
+ $command .= " -d \'" . $$new_data[$users_prop_map{"home"}] . "\'"
|
|
482 |
+ if ( $$new_data[$users_prop_map{"home"}] ne $$old_data[$users_prop_map{"home"}] );
|
|
483 |
+ $command .= " -s \'" . $$new_data[$users_prop_map{"shell"}] . "\'"
|
|
484 |
+ if ( $$new_data[$users_prop_map{"shell"}] ne $$old_data[$users_prop_map{"shell"}] );
|
|
| 8436 | 485 |
+ |
486 |
+ if ($$new_data[$users_prop_map{"rbac"}] ne undef ) {
|
|
| 15693 | 487 |
+ my (@old_profiles, @new_profiles, $old_user_profiles, $new_user_profiles ); |
488 |
+ my $change = 0; |
|
| 8436 | 489 |
+ $old_user_profiles = $$old_data[$users_prop_map{"rbac"}];
|
490 |
+ $new_user_profiles = $$new_data[$users_prop_map{"rbac"}];
|
|
| 15693 | 491 |
+ @old_profiles = (); |
492 |
+ @new_profiles = (); |
|
| 8436 | 493 |
+ if ( $old_user_profiles eq undef ) {
|
494 |
+ # All new profiles, so just use directly |
|
495 |
+ &gst_report("RBAC profiles created for ". $$old_data[$users_prop_map{"login"}] );
|
|
| 15693 | 496 |
+ push( @new_profiles, @$new_user_profiles ); |
497 |
+ push( @old_profiles, @$old_user_profiles ); |
|
| 8436 | 498 |
+ } |
499 |
+ else {
|
|
500 |
+ my @sorted_old_user_profiles = sort(@$old_user_profiles); |
|
501 |
+ my @sorted_new_user_profiles = sort(@$new_user_profiles); |
|
502 |
+ if ( &arr_cmp_recurse( \@sorted_new_user_profiles, \@sorted_old_user_profiles) ) {
|
|
503 |
+ &gst_report("RBAC profiles changed for ". $$old_data[$users_prop_map{"login"}] );
|
|
| 15693 | 504 |
+ push( @new_profiles, @$new_user_profiles ); # Copy unsorted list |
505 |
+ push( @old_profiles, @$old_user_profiles ); |
|
506 |
+ $change = 1; |
|
507 |
+ } |
|
| 8436 | 508 |
+ } |
| 15693 | 509 |
+ if ( $#new_profiles >= 0 ) {
|
| 8436 | 510 |
+ my $profiles_str = ""; |
| 15693 | 511 |
+ foreach ( @old_profiles ) {
|
512 |
+ $tmp = $_; |
|
513 |
+ foreach ( @new_profiles ) {
|
|
514 |
+ if ( $tmp eq $_ ) {
|
|
515 |
+ $profiles_str .= ',' unless ( $profiles_str eq "" ); |
|
516 |
+ $profiles_str .= $tmp; |
|
517 |
+ last; |
|
518 |
+ } |
|
519 |
+ } |
|
| 8436 | 520 |
+ } |
| 15693 | 521 |
+ |
522 |
+ foreach ( @new_profiles ) {
|
|
523 |
+ $tmp = $_; |
|
524 |
+ $found = 0; |
|
525 |
+ foreach ( @old_profiles ) {
|
|
526 |
+ if ( $tmp eq $_ ) {
|
|
527 |
+ $found = 1; |
|
528 |
+ last; |
|
529 |
+ } |
|
530 |
+ } |
|
531 |
+ if ( !$found ) {
|
|
532 |
+ $profiles_str .= ',' unless ( $profiles_str eq "" ); |
|
533 |
+ $profiles_str .= $tmp; |
|
534 |
+ } |
|
535 |
+ } |
|
536 |
+ |
|
| 8436 | 537 |
+ $command .= " -P \'" . $profiles_str . "\'"; |
| 15693 | 538 |
+ } else {
|
539 |
+ $command .= " -P \'\'" if ( $change ); |
|
540 |
+ } |
|
| 8436 | 541 |
+ } |
| 13240 | 542 |
+ |
543 |
+ if ($$new_data[$users_prop_map{"role"}] ne undef ) {
|
|
544 |
+ my (@roles, $old_user_roles, $new_user_roles ); |
|
| 15693 | 545 |
+ my $change = 0; |
| 13240 | 546 |
+ $old_user_roles = $$old_data[$users_prop_map{"role"}];
|
547 |
+ $new_user_roles = $$new_data[$users_prop_map{"role"}];
|
|
548 |
+ @roles = (); |
|
549 |
+ if ( $old_user_roles eq undef ) {
|
|
550 |
+ # All new roles, so just use directly |
|
551 |
+ &gst_report("RBAC roles created for ". $$old_data[$users_prop_map{"login"}] );
|
|
552 |
+ push( @roles, @$new_user_roles ); |
|
553 |
+ } |
|
554 |
+ else {
|
|
555 |
+ my @sorted_old_user_roles = sort(@$old_user_roles); |
|
556 |
+ my @sorted_new_user_roles = sort(@$new_user_roles); |
|
557 |
+ if ( &arr_cmp_recurse( \@sorted_new_user_roles, \@sorted_old_user_roles) ) {
|
|
558 |
+ &gst_report("RBAC roles changed for ". $$old_data[$users_prop_map{"login"}] );
|
|
559 |
+ push( @roles, @$new_user_roles ); # Copy unsorted list |
|
| 15693 | 560 |
+ $change = 1; |
| 13240 | 561 |
+ } |
562 |
+ } |
|
563 |
+ if ( $#roles >= 0 ) {
|
|
564 |
+ my $roles_str = ""; |
|
565 |
+ foreach ( @roles ) {
|
|
566 |
+ $roles_str .= ',' unless ( $roles_str eq "" ); |
|
567 |
+ $roles_str .= $_; |
|
568 |
+ } |
|
569 |
+ $command .= " -R \'" . $roles_str . "\'"; |
|
570 |
+ } else {
|
|
| 15693 | 571 |
+ $command .= " -R \'\'" if ( $change); |
| 13240 | 572 |
+ } |
573 |
+ } |
|
574 |
+ |
|
| 7860 | 575 |
+ # If there's nothing to change, then don't... |
576 |
+ if ( $command ne $cmd_usermod ) {
|
|
| 8436 | 577 |
+ $command .= " \'" . $$old_data[$users_prop_map{"login"}] . "\'";
|
| 7860 | 578 |
+ &gst_file_run ($command); |
579 |
+ } |
|
580 |
+ $username = $$old_data[$users_prop_map{"login"}];
|
|
581 |
+ $oldpassword = $$old_data[$users_prop_map{"password"}];
|
|
582 |
+ $newpassword = $$new_data[$users_prop_map{"password"}];
|
|
583 |
+ # Should only change password if old and new differ - this is especially |
|
584 |
+ # important since the old password is usually the "crypted" one!! Only if |
|
585 |
+ # it's different has a user entered a clear string here. |
|
| 8436 | 586 |
+ if ( $newpassword ne undef && $newpassword ne $oldpassword ) {
|
| 7860 | 587 |
+ ref($pamh = new Authen::PAM($service, $username, \&my_conv_func)); |
588 |
+ $pamh->pam_chauthtok(PAM_NO_AUTHTOK_CHECK()); |
|
589 |
+ } |
|
590 |
+ } |
|
591 |
else |
|
592 |
{
|
|
593 |
$command = "$cmd_usermod" . " -d \'" . $$new_data[$users_prop_map{"home"}] .
|
|
| 15698 | 594 |
@@ -1026,8 +1436,24 @@ sub add_group |
| 7860 | 595 |
|
596 |
foreach $user (@$u) |
|
597 |
{
|
|
598 |
- $command = "$cmd_gpasswd -a \'" . $user . |
|
599 |
- "\' " . $$data[$groups_prop_map{"name"}];
|
|
600 |
+ if ($gst_dist =~ /^solaris/) |
|
601 |
+ {
|
|
602 |
+ my ($groups, @a); |
|
603 |
+ $command = "groups \'" . $user . "\'"; |
|
604 |
+ $groups = &gst_file_run_backtick ($command); |
|
605 |
+ chomp ($groups); |
|
606 |
+ @a = split (/ /, $groups); |
|
607 |
+ $groups = join (',', @a);
|
|
608 |
+ |
|
609 |
+ $command = "$cmd_usermod -G " . $groups . "," . |
|
610 |
+ $$data[$groups_prop_map{"name"}] . " " .
|
|
611 |
+ $user . " "; |
|
612 |
+ } |
|
613 |
+ else |
|
614 |
+ {
|
|
615 |
+ $command = "$cmd_gpasswd -a \'" . $user . |
|
616 |
+ "\' " . $$data[$groups_prop_map{"name"}];
|
|
617 |
+ } |
|
618 |
&gst_file_run ($command); |
|
619 |
} |
|
620 |
} |
|
| 15698 | 621 |
@@ -1052,10 +1478,18 @@ sub change_group |
| 11320 | 622 |
} |
623 |
else |
|
624 |
{
|
|
625 |
- $command = "$cmd_groupmod -g \'" . $$new_data[$groups_prop_map{"gid"}] .
|
|
626 |
- "\' -n \'" . $$new_data[$groups_prop_map{"name"}] . "\' " .
|
|
627 |
- "\'" . $$old_data[$groups_prop_map{"name"}] . "\'";
|
|
628 |
- |
|
629 |
+ if ( $$new_data[$groups_propmap{"name"}] eq $$old_data[$group_prop_map{"name"}] )
|
|
630 |
+ {
|
|
631 |
+ $command = "$cmd_groupmod -g \'" . $$new_data[$groups_prop_map{"gid"}] .
|
|
632 |
+ "\' \'" . $$old_data[$groups_prop_map{"name"}] . "\'";
|
|
633 |
+ } |
|
634 |
+ else |
|
635 |
+ {
|
|
636 |
+ $command = "$cmd_groupmod -g \'" . $$new_data[$groups_prop_map{"gid"}] .
|
|
637 |
+ "\' -n \'" . $$new_data[$groups_prop_map{"name"}] . "\' " .
|
|
638 |
+ "\'" . $$old_data[$groups_prop_map{"name"}] . "\'";
|
|
639 |
+ } |
|
640 |
+ |
|
641 |
&gst_file_run ($command); |
|
642 |
||
643 |
# Let's see if the users that compose the group have changed. |
|
| 15698 | 644 |
@@ -1069,25 +1503,62 @@ sub change_group |
| 7860 | 645 |
$max_o = $#$o; |
646 |
for ($i = 0, $j = 0; $i <= &max ($max_n, $max_o); ) {
|
|
647 |
$r = $$n[$i] cmp $$o[$j]; |
|
648 |
- $r *= -1 if (($$o[$j] eq "") || ($$n[$i] eq "")); |
|
649 |
||
650 |
- if ($r < 0) { # add this user to the group.
|
|
651 |
- $command = "$cmd_gpasswd -a \'" . $$n[$i] . "\' \'" . |
|
652 |
- $$new_data[$groups_prop_map{"name"}] . "\'";
|
|
653 |
+ if ($r > 0) { # add this user to the group.
|
|
654 |
+ if ($gst_dist =~ /^solaris/) |
|
655 |
+ {
|
|
656 |
+ my ($groups, @a); |
|
657 |
+ $command = "groups \'" . $$n[$i] . "\'"; |
|
658 |
+ $groups = &gst_file_run_backtick ($command); |
|
659 |
+ chomp ($groups); |
|
660 |
+ @a = split (/ /, $groups); |
|
661 |
+ $groups = join (',', @a);
|
|
662 |
+ |
|
663 |
+ $command = "$cmd_usermod -G " . $groups . "," . |
|
664 |
+ $$new_data[$groups_prop_map{"name"}] . " " .
|
|
665 |
+ $$n[$i] . " "; |
|
666 |
+ } |
|
667 |
+ else |
|
668 |
+ {
|
|
669 |
+ $command = "$cmd_gpasswd -a " . $$n[$i] . " " . $$new_data[$groups_prop_map{"name"}] . " ";
|
|
670 |
+ } |
|
671 |
$i ++; |
|
672 |
- |
|
673 |
+ |
|
674 |
&gst_file_run ($command); |
|
675 |
- } elsif ($r > 0) { # delete the user from the group.
|
|
676 |
- $command = "$cmd_gpasswd -d \'" . $$o[$j] . "\' \'" . |
|
677 |
- $$new_data[$groups_prop_map{"name"}] . "\'";
|
|
678 |
+ } elsif ($r < 0) { # delete the user from the group.
|
|
679 |
+ if ($gst_dist =~ /^solaris/) |
|
680 |
+ {
|
|
681 |
+ my ($groups, @a, $k); |
|
682 |
+ $command = "groups \'" . $$o[$j] . "\'"; |
|
683 |
+ $groups = &gst_file_run_backtick ($command); |
|
684 |
+ chomp ($groups); |
|
685 |
+ @a = split (/ /, $groups); |
|
686 |
+ for ($k = 0; $k < $#a + 1; $k++) |
|
687 |
+ {
|
|
688 |
+ if ($a[$k] eq $$new_data[$groups_prop_map{"name"}])
|
|
689 |
+ {
|
|
690 |
+ splice (@a, $k, 1); |
|
691 |
+ last; |
|
692 |
+ } |
|
693 |
+ } |
|
694 |
+ $groups = join (',', @a);
|
|
695 |
+ |
|
696 |
+ $command = "$cmd_usermod -G " . $groups . " " . |
|
697 |
+ $$o[$j] . " "; |
|
698 |
+ } |
|
699 |
+ else |
|
700 |
+ {
|
|
701 |
+ $command = "$cmd_gpasswd -d \'" . $$o[$j] . "\' \'" . |
|
702 |
+ $$new_data[$groups_prop_map{"name"}] . "\'";
|
|
703 |
+ } |
|
704 |
$j ++; |
|
705 |
- |
|
706 |
+ |
|
707 |
&gst_file_run ($command); |
|
708 |
- } else { # The information is the same. Go to next tuple.
|
|
709 |
+ } else { # The information is the same. Go to next tuple.
|
|
710 |
$i ++; $j ++; |
|
711 |
- } |
|
712 |
- } |
|
713 |
- } |
|
714 |
+ } |
|
715 |
+ } |
|
716 |
+ } |
|
717 |
} |
|
718 |
} |
|
719 |
||
| 15698 | 720 |
@@ -1204,8 +1675,11 @@ sub xml_parse_users |
| 7860 | 721 |
elsif ($$tree[0] eq "group_last_modified") { &xml_parse_group_last_modified ($$tree[1], $hash); }
|
722 |
elsif ($$tree[0] eq "userdb") { &xml_parse_userdb ($$tree[1], $hash); }
|
|
723 |
elsif ($$tree[0] eq "groupdb") { &xml_parse_groupdb ($$tree[1], $hash); }
|
|
724 |
+ elsif ($$tree[0] eq "use_md5") { }
|
|
725 |
elsif ($$tree[0] eq "shelldb") { }
|
|
726 |
elsif ($$tree[0] eq "profiledb") { &xml_parse_profiledb ($$tree[1], $hash); }
|
|
| 8436 | 727 |
+ elsif ($$tree[0] eq "rbacdb") { } # if rbacdb is there ignore, can't be changed.
|
| 13240 | 728 |
+ elsif ($$tree[0] eq "roledb") { } # if roledb is there ignore, can't be changed.
|
| 7860 | 729 |
else |
| 8436 | 730 |
{
|
731 |
&gst_report ("xml_unexp_tag", $$tree[0]);
|
|
| 15698 | 732 |
@@ -1268,18 +1742,60 @@ sub xml_parse_user |
| 8436 | 733 |
|
734 |
while (@$tree) |
|
735 |
{
|
|
736 |
- if ($users_prop_map{$$tree[0]} ne undef)
|
|
| 13240 | 737 |
+ if ($users_prop_map{$$tree[0]} ne undef && $$tree[0] ne "rbac" && $$tree[0] ne "role" )
|
| 8436 | 738 |
{
|
739 |
$line[$users_prop_map{$$tree[0]}] = &gst_xml_unquote($$tree[1][2]);
|
|
740 |
} |
|
| 13240 | 741 |
- else |
742 |
- {
|
|
743 |
- &gst_report ("xml_unexp_tag", $$tree[0]);
|
|
744 |
- } |
|
745 |
- |
|
746 |
- shift @$tree; |
|
747 |
- shift @$tree; |
|
748 |
- } |
|
| 8436 | 749 |
+ elsif ($$tree[0] eq "rbac") |
750 |
+ {
|
|
751 |
+ my $rbac = $$tree[1]; # rbac children |
|
752 |
+ shift @$rbac; # Skip attributes |
|
753 |
+ my $rbac_profiles = $$rbac[1]; # rbac children |
|
754 |
+ shift @$rbac_profiles; # Skip attributes |
|
| 15698 | 755 |
+ |
| 8436 | 756 |
+ my @user_profiles; |
757 |
+ # my $users_rbac_profiles = $$hash{"users_rbac_profiles"};
|
|
758 |
+ |
|
759 |
+ # if ( $users_rbac_profiles eq undef ) { # Allocate a new one if none exists
|
|
760 |
+ # my %dummy = (); |
|
761 |
+ # $users_rbac_profiles = \%dummy; |
|
762 |
+ # $$hash{"users_rbac_profiles"} = $users_rbac_profiles;
|
|
763 |
+ #} |
|
764 |
+ |
|
765 |
+ while (@$rbac_profiles) {
|
|
766 |
+ my $profile = $$rbac_profiles[1][2]; |
|
| 10454 | 767 |
+ push(@user_profiles, $profile ); |
| 8436 | 768 |
+ shift( @$rbac_profiles ); |
769 |
+ shift( @$rbac_profiles ); |
|
770 |
+ } |
|
771 |
+ #$$users_rbac_profiles{ $line[$users_prop_map{"login"}] } = \@user_profiles;
|
|
772 |
+ #XXX Here |
|
773 |
+ $line[$users_prop_map{$$tree[0]}] = \@user_profiles;
|
|
774 |
+ } |
|
| 13240 | 775 |
+ elsif ($$tree[0] eq "role") |
776 |
+ {
|
|
777 |
+ my $role = $$tree[1]; # role children |
|
778 |
+ shift @$role; # Skip attributes |
|
779 |
+ my $role_lists = $$role[1]; # role children |
|
780 |
+ shift @$role_lists; # Skip attributes |
|
781 |
+ |
|
782 |
+ my @user_roles; |
|
783 |
+ |
|
784 |
+ while (@$role_lists) {
|
|
785 |
+ my $role = $$role_lists[1][2]; |
|
786 |
+ push(@user_roles, $role ); |
|
787 |
+ shift( @$role_lists ); |
|
788 |
+ shift( @$role_lists ); |
|
789 |
+ } |
|
790 |
+ $line[$users_prop_map{$$tree[0]}] = \@user_roles;
|
|
791 |
+ } |
|
792 |
+ else |
|
793 |
+ {
|
|
794 |
+ &gst_report ("xml_unexp_tag", $$tree[0]);
|
|
795 |
+ } |
|
796 |
+ shift @$tree; |
|
797 |
+ shift @$tree; |
|
798 |
+ } |
|
| 15698 | 799 |
|
| 13240 | 800 |
$$users_hash{sprintf ("%06d", $line[0])} = [@line];
|
801 |
push (@$users, [@line]); |
|
| 15698 | 802 |
@@ -1323,6 +1839,7 @@ sub xml_parse_group |
| 7860 | 803 |
if ($$tree[0] eq "users") { $line[$groups_prop_map{$$tree[0]}] = $$tree[1]; }
|
804 |
else { $line[$groups_prop_map{$$tree[0]}] = $$tree[1][2]; }
|
|
805 |
} |
|
806 |
+ elsif ($$tree[0] eq "allows_to") { }
|
|
807 |
else |
|
808 |
{
|
|
809 |
&gst_report ("xml_unexp_tag", $$tree[0]);
|
|
| 15698 | 810 |
@@ -1487,11 +2004,20 @@ sub xml_print |
| 8121 | 811 |
my ($hash) = @_; |
812 |
my ($key, $value, $i, $j, $k); |
|
813 |
my ($passwd_last_modified, $users, $desc); |
|
| 8436 | 814 |
+ # my ($users_rbac_profiles); |
| 13240 | 815 |
+ my ($rbac, $rbac_profiles, $role, $rbac_roles); |
| 8121 | 816 |
|
817 |
$passwd_last_modified = $$hash{"passwd_last_modified"};
|
|
818 |
$users = $$hash{"users"};
|
|
819 |
$group_last_modified = $$hash{"group_last_modified"};
|
|
820 |
$groups = $$hash{"groups"};
|
|
821 |
+ if ( $gst_dist =~ /^solaris/ ) {
|
|
822 |
+ $rbac = $$hash{"rbacdb"};
|
|
823 |
+ $rbac_profiles = $$rbac{"rbac_profiles"};
|
|
| 13240 | 824 |
+ $role = $$hash{"roledb"};
|
825 |
+ $rbac_roles = $$role{"rbac_roles"};
|
|
| 8436 | 826 |
+ # $users_rbac_profiles = $$hash{"users_rbac_profiles"};
|
| 8121 | 827 |
+ } |
828 |
||
829 |
&gst_xml_print_begin (); |
|
830 |
||
| 15698 | 831 |
@@ -1519,8 +2045,35 @@ sub xml_print |
| 8436 | 832 |
&gst_xml_container_enter ('user');
|
833 |
for ($j = 0; $j < ($#users_prop_array - 1) / 2; $j++) |
|
| 8121 | 834 |
{
|
| 8436 | 835 |
- &gst_xml_print_pcdata ($users_prop_map{$j}, $$i[$j]);
|
836 |
+ if ( $users_prop_map{$j} eq "rbac" && $gst_dist =~ /^solaris/ ) {
|
|
837 |
+ my ($user_profiles); |
|
838 |
+ &gst_xml_container_enter ('rbac');
|
|
839 |
+ &gst_xml_container_enter ('rbac_profiles');
|
|
840 |
+ # $user_profiles = $$users_rbac_profiles{$$i[1]};
|
|
841 |
+ $user_profiles = $$i[$j]; |
|
842 |
+ foreach $prof ( @$user_profiles ) {
|
|
843 |
+ &gst_xml_print_pcdata ("rbac_profile", $prof);
|
|
844 |
+ } |
|
845 |
+ &gst_xml_container_leave (); |
|
846 |
+ &gst_xml_container_leave (); |
|
847 |
+ } |
|
| 13240 | 848 |
+ elsif ( $users_prop_map{$j} eq "role" && $gst_dist =~ /^solaris/ ) {
|
849 |
+ my ($user_roles); |
|
850 |
+ &gst_xml_container_enter ('role');
|
|
851 |
+ &gst_xml_container_enter ('rbac_roles');
|
|
852 |
+ # $user_profiles = $$users_rbac_profiles{$$i[1]};
|
|
853 |
+ $user_roles = $$i[$j]; |
|
854 |
+ foreach $role ( @$user_roles ) {
|
|
855 |
+ &gst_xml_print_pcdata ("rbac_role", $role);
|
|
856 |
+ } |
|
857 |
+ &gst_xml_container_leave (); |
|
858 |
+ &gst_xml_container_leave (); |
|
859 |
+ } |
|
| 8436 | 860 |
+ else {
|
861 |
+ &gst_xml_print_pcdata ($users_prop_map{$j}, $$i[$j]);
|
|
862 |
+ } |
|
| 8121 | 863 |
} |
864 |
+ |
|
865 |
&gst_xml_container_leave (); |
|
866 |
} |
|
867 |
&gst_xml_container_leave (); |
|
| 15698 | 868 |
@@ -1559,9 +2112,47 @@ sub xml_print |
| 8121 | 869 |
&gst_xml_container_leave (); |
870 |
} |
|
871 |
&gst_xml_container_leave (); |
|
872 |
- &gst_xml_print_vspace (); |
|
873 |
||
874 |
- &gst_xml_print_end (); |
|
875 |
+ if ( $gst_dist =~ /^solaris/ ) {
|
|
876 |
+ &gst_xml_print_vspace (); |
|
877 |
+ |
|
878 |
+ &gst_xml_print_comment ('Now the RBAC Profiles');
|
|
879 |
+ &gst_xml_print_vspace (); |
|
880 |
+ |
|
881 |
+ &gst_xml_container_enter ('rbacdb');
|
|
882 |
+ &gst_xml_container_enter ('rbac_profiles');
|
|
883 |
+ |
|
884 |
+ foreach $prof ( sort keys %$rbac_profiles ) |
|
885 |
+ {
|
|
886 |
+ &gst_xml_print_vspace (); |
|
887 |
+ &gst_xml_container_enter ('rbac_profile');
|
|
888 |
+ &gst_xml_print_pcdata ('name', $prof );
|
|
889 |
+ &gst_xml_print_pcdata ('description', $$rbac_profiles{$prof} );
|
|
890 |
+ &gst_xml_container_leave (); |
|
891 |
+ } |
|
892 |
+ &gst_xml_container_leave (); |
|
893 |
+ &gst_xml_container_leave (); |
|
894 |
+ &gst_xml_print_vspace (); |
|
| 13240 | 895 |
+ |
896 |
+ &gst_xml_print_comment ('Now the ROLE');
|
|
897 |
+ &gst_xml_print_vspace (); |
|
898 |
+ |
|
899 |
+ &gst_xml_container_enter ('roledb');
|
|
900 |
+ &gst_xml_container_enter ('rbac_roles');
|
|
901 |
+ |
|
902 |
+ foreach $role ( sort keys %$rbac_roles ) |
|
903 |
+ {
|
|
904 |
+ &gst_xml_print_vspace (); |
|
905 |
+ &gst_xml_container_enter ('rbac_role');
|
|
906 |
+ &gst_xml_print_pcdata ('role', $role );
|
|
907 |
+ &gst_xml_container_leave (); |
|
908 |
+ } |
|
909 |
+ &gst_xml_container_leave (); |
|
910 |
+ &gst_xml_container_leave (); |
|
911 |
+ &gst_xml_print_vspace (); |
|
| 8121 | 912 |
+ } |
913 |
+ |
|
914 |
+ &gst_xml_print_end (); |
|
915 |
} |
|
916 |
||
917 |
||
| 15698 | 918 |
@@ -1590,6 +2181,7 @@ sub set |
| 8121 | 919 |
&gst_file_backup ($_) foreach (@passwd_names); |
920 |
&gst_file_backup ($_) foreach (@shadow_names); |
|
921 |
&gst_file_backup ($_) foreach (@group_names); |
|
922 |
+ &gst_file_backup ($_) foreach (@rbac_names); |
|
923 |
||
924 |
&write_profiledb ($hash); |
|
925 |
&write_group_passwd ($hash); |
|
| 15698 | 926 |
@@ -1627,6 +2219,7 @@ $directives = {
|
| 7860 | 927 |
$tool = &gst_init ($name, $version, $description, $directives, @ARGV); |
928 |
&gst_platform_ensure_supported ($tool, @platforms); |
|
929 |
||
930 |
+&get_users_prop_array (); |
|
931 |
&get_login_defs_prop_array (); |
|
932 |
&get_profiles_prop_array (); |
|
933 |
||
| 15698 | 934 |
|
935 |
diff -up system-tools-backends-1.4.2/Makefile.am.orig system-tools-backends-1.4.2/Makefile.am |
|
936 |
--- system-tools-backends-1.4.2/Makefile.am.orig 2005-02-23 14:31:25.000000000 +0000 |
|
937 |
+++ system-tools-backends-1.4.2/Makefile.am 2009-05-01 10:52:18.828515674 +0100 |
|
938 |
@@ -18,6 +18,8 @@ backends = \ |
|
939 |
font-conf |
|
940 |
||
941 |
perl_libs = \ |
|
942 |
+ user_attr.pm \ |
|
943 |
+ user_attr.so \ |
|
944 |
boot.pl \ |
|
945 |
boot-grub.pl \ |
|
946 |
boot-lilo.pl \ |
|
947 |
||
948 |
diff -up system-tools-backends-1.4.2/Makefile.in.orig system-tools-backends-1.4.2/Makefile.in |
|
949 |
--- system-tools-backends-1.4.2/Makefile.in.orig 2009-05-01 10:52:40.000000000 +0100 |
|
950 |
+++ system-tools-backends-1.4.2/Makefile.in 2009-05-01 11:21:42.782223461 +0100 |
|
951 |
@@ -194,6 +194,13 @@ backends = \ |
|
952 |
font-conf |
|
953 |
||
954 |
||
955 |
+secdb_libs = \ |
|
956 |
+ secdb.so |
|
957 |
+ |
|
958 |
+secdb_files = \ |
|
959 |
+ secdb.pm \ |
|
960 |
+ $(secdb_libs) |
|
961 |
+ |
|
962 |
perl_libs = \ |
|
963 |
boot.pl \ |
|
964 |
boot-grub.pl \ |
|
965 |
@@ -224,7 +231,7 @@ perl_libs = \ |
|
966 |
xml.pl |
|
967 |
||
968 |
||
969 |
-scripts_SCRIPTS = $(backends) $(perl_libs) guess_system.sh type1inst |
|
970 |
+scripts_SCRIPTS = $(backends) $(perl_libs) guess_system.sh type1inst $(secdb_files) |
|
971 |
||
972 |
EXTRA_DIST = \ |
|
973 |
intltool-extract.in \ |
|
974 |
@@ -238,7 +245,7 @@ EXTRA_DIST = \ |
|
975 |
NEWS |
|
976 |
||
977 |
||
978 |
-CLEANFILES = $(backends) $(perl_libs) |
|
979 |
+CLEANFILES = $(backends) $(perl_libs) $(secdb_libs) |
|
980 |
||
981 |
DISTCLEANFILES = \ |
|
982 |
intltool-extract \ |
|
983 |
@@ -295,6 +302,13 @@ all: config.h |
|
984 |
||
985 |
.SUFFIXES: |
|
986 |
||
987 |
+secdb_wrap.o: secdb_wrap.c |
|
988 |
+ $(CC) -c secdb_wrap.c `perl -MExtUtils::Embed -e ccopts` |
|
989 |
+ |
|
990 |
+secdb.so: secdb_wrap.o |
|
991 |
+ $(LD) -G secdb_wrap.o -o secdb.so -lsecdb |
|
992 |
+ |
|
993 |
+ |
|
994 |
am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ |
|
995 |
configure.lineno |
|
996 |
$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) |
|
997 |
||
998 |
diff -up system-tools-backends-1.4.2/secdb.i.orig system-tools-backends-1.4.2/secdb.i |
|
999 |
--- system-tools-backends-1.4.2/secdb.i.orig 2009-05-01 14:10:51.392529355 +0100 |
|
1000 |
+++ system-tools-backends-1.4.2/secdb.i 2009-05-01 11:29:10.761689758 +0100 |
|
1001 |
@@ -0,0 +1,11 @@ |
|
1002 |
+%module secdb |
|
1003 |
+%{
|
|
1004 |
+#include "prof_attr.h" |
|
1005 |
+#include "secdb.h" |
|
1006 |
+#include "user_attr.h" |
|
1007 |
+%} |
|
1008 |
+ |
|
1009 |
+%include "prof_attr.h" |
|
1010 |
+%include "user_attr.h" |
|
1011 |
+%include "secdb.h" |
|
1012 |
+ |
|
1013 |
||
| 20005 | 1014 |
--- system-tools-backends-1.4.2/secdb.pm 1970-01-01 10:00:00.000000000 +1000 |
1015 |
+++ system-tools-backends-1.4.2.new/secdb.pm 2010-08-05 16:34:58.891880880 +1000 |
|
1016 |
@@ -0,0 +1,447 @@ |
|
| 15698 | 1017 |
+# This file was automatically generated by SWIG (http://www.swig.org). |
1018 |
+# Version 1.3.35 |
|
1019 |
+# |
|
1020 |
+# Don't modify this file, modify the SWIG interface instead. |
|
1021 |
+ |
|
1022 |
+package secdb; |
|
1023 |
+require Exporter; |
|
1024 |
+require DynaLoader; |
|
1025 |
+@ISA = qw(Exporter DynaLoader); |
|
1026 |
+package secdbc; |
|
1027 |
+bootstrap secdb; |
|
1028 |
+package secdb; |
|
1029 |
+@EXPORT = qw( ); |
|
1030 |
+ |
|
1031 |
+# ---------- BASE METHODS ------------- |
|
1032 |
+ |
|
1033 |
+package secdb; |
|
1034 |
+ |
|
1035 |
+sub TIEHASH {
|
|
1036 |
+ my ($classname,$obj) = @_; |
|
1037 |
+ return bless $obj, $classname; |
|
1038 |
+} |
|
1039 |
+ |
|
1040 |
+sub CLEAR { }
|
|
1041 |
+ |
|
1042 |
+sub FIRSTKEY { }
|
|
1043 |
+ |
|
1044 |
+sub NEXTKEY { }
|
|
1045 |
+ |
|
1046 |
+sub FETCH {
|
|
1047 |
+ my ($self,$field) = @_; |
|
1048 |
+ my $member_func = "swig_${field}_get";
|
|
1049 |
+ $self->$member_func(); |
|
1050 |
+} |
|
1051 |
+ |
|
1052 |
+sub STORE {
|
|
1053 |
+ my ($self,$field,$newval) = @_; |
|
1054 |
+ my $member_func = "swig_${field}_set";
|
|
1055 |
+ $self->$member_func($newval); |
|
1056 |
+} |
|
1057 |
+ |
|
1058 |
+sub this {
|
|
1059 |
+ my $ptr = shift; |
|
1060 |
+ return tied(%$ptr); |
|
1061 |
+} |
|
1062 |
+ |
|
1063 |
+ |
|
1064 |
+# ------- FUNCTION WRAPPERS -------- |
|
1065 |
+ |
|
1066 |
+package secdb; |
|
1067 |
+ |
|
1068 |
+*getprofnam = *secdbc::getprofnam; |
|
1069 |
+*getprofattr = *secdbc::getprofattr; |
|
1070 |
+*getproflist = *secdbc::getproflist; |
|
1071 |
+*setprofattr = *secdbc::setprofattr; |
|
1072 |
+*endprofattr = *secdbc::endprofattr; |
|
1073 |
+*free_profattr = *secdbc::free_profattr; |
|
1074 |
+*free_proflist = *secdbc::free_proflist; |
|
1075 |
+*getusernam = *secdbc::getusernam; |
|
1076 |
+*getuseruid = *secdbc::getuseruid; |
|
1077 |
+*getuserattr = *secdbc::getuserattr; |
|
1078 |
+*fgetuserattr = *secdbc::fgetuserattr; |
|
1079 |
+*setuserattr = *secdbc::setuserattr; |
|
1080 |
+*enduserattr = *secdbc::enduserattr; |
|
1081 |
+*free_userattr = *secdbc::free_userattr; |
|
1082 |
+*kva_match = *secdbc::kva_match; |
|
1083 |
+*_auth_match = *secdbc::_auth_match; |
|
1084 |
+*_argv_to_csl = *secdbc::_argv_to_csl; |
|
1085 |
+*_csl_to_argv = *secdbc::_csl_to_argv; |
|
1086 |
+*_do_unescape = *secdbc::_do_unescape; |
|
1087 |
+*_free_argv = *secdbc::_free_argv; |
|
1088 |
+*_insert2kva = *secdbc::_insert2kva; |
|
1089 |
+*_kva2str = *secdbc::_kva2str; |
|
1090 |
+*_kva_dup = *secdbc::_kva_dup; |
|
1091 |
+*_kva_free = *secdbc::_kva_free; |
|
1092 |
+*_new_kva = *secdbc::_new_kva; |
|
1093 |
+*_str2kva = *secdbc::_str2kva; |
|
1094 |
+ |
|
1095 |
+############# Class : secdb::profstr_t ############## |
|
1096 |
+ |
|
1097 |
+package secdb::profstr_t; |
|
1098 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1099 |
+@ISA = qw( secdb ); |
|
1100 |
+%OWNER = (); |
|
1101 |
+%ITERATORS = (); |
|
1102 |
+*swig_name_get = *secdbc::profstr_t_name_get; |
|
1103 |
+*swig_name_set = *secdbc::profstr_t_name_set; |
|
1104 |
+*swig_res1_get = *secdbc::profstr_t_res1_get; |
|
1105 |
+*swig_res1_set = *secdbc::profstr_t_res1_set; |
|
1106 |
+*swig_res2_get = *secdbc::profstr_t_res2_get; |
|
1107 |
+*swig_res2_set = *secdbc::profstr_t_res2_set; |
|
1108 |
+*swig_desc_get = *secdbc::profstr_t_desc_get; |
|
1109 |
+*swig_desc_set = *secdbc::profstr_t_desc_set; |
|
1110 |
+*swig_attr_get = *secdbc::profstr_t_attr_get; |
|
1111 |
+*swig_attr_set = *secdbc::profstr_t_attr_set; |
|
1112 |
+sub new {
|
|
1113 |
+ my $pkg = shift; |
|
1114 |
+ my $self = secdbc::new_profstr_t(@_); |
|
1115 |
+ bless $self, $pkg if defined($self); |
|
1116 |
+} |
|
1117 |
+ |
|
1118 |
+sub DESTROY {
|
|
1119 |
+ return unless $_[0]->isa('HASH');
|
|
1120 |
+ my $self = tied(%{$_[0]});
|
|
1121 |
+ return unless defined $self; |
|
1122 |
+ delete $ITERATORS{$self};
|
|
1123 |
+ if (exists $OWNER{$self}) {
|
|
1124 |
+ secdbc::delete_profstr_t($self); |
|
1125 |
+ delete $OWNER{$self};
|
|
1126 |
+ } |
|
1127 |
+} |
|
1128 |
+ |
|
1129 |
+sub DISOWN {
|
|
1130 |
+ my $self = shift; |
|
1131 |
+ my $ptr = tied(%$self); |
|
1132 |
+ delete $OWNER{$ptr};
|
|
1133 |
+} |
|
1134 |
+ |
|
1135 |
+sub ACQUIRE {
|
|
1136 |
+ my $self = shift; |
|
1137 |
+ my $ptr = tied(%$self); |
|
1138 |
+ $OWNER{$ptr} = 1;
|
|
1139 |
+} |
|
1140 |
+ |
|
1141 |
+ |
|
1142 |
+############# Class : secdb::profattr_t ############## |
|
1143 |
+ |
|
1144 |
+package secdb::profattr_t; |
|
1145 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1146 |
+@ISA = qw( secdb ); |
|
1147 |
+%OWNER = (); |
|
1148 |
+%ITERATORS = (); |
|
1149 |
+*swig_name_get = *secdbc::profattr_t_name_get; |
|
1150 |
+*swig_name_set = *secdbc::profattr_t_name_set; |
|
1151 |
+*swig_res1_get = *secdbc::profattr_t_res1_get; |
|
1152 |
+*swig_res1_set = *secdbc::profattr_t_res1_set; |
|
1153 |
+*swig_res2_get = *secdbc::profattr_t_res2_get; |
|
1154 |
+*swig_res2_set = *secdbc::profattr_t_res2_set; |
|
1155 |
+*swig_desc_get = *secdbc::profattr_t_desc_get; |
|
1156 |
+*swig_desc_set = *secdbc::profattr_t_desc_set; |
|
1157 |
+*swig_attr_get = *secdbc::profattr_t_attr_get; |
|
1158 |
+*swig_attr_set = *secdbc::profattr_t_attr_set; |
|
1159 |
+sub new {
|
|
1160 |
+ my $pkg = shift; |
|
1161 |
+ my $self = secdbc::new_profattr_t(@_); |
|
1162 |
+ bless $self, $pkg if defined($self); |
|
1163 |
+} |
|
1164 |
+ |
|
1165 |
+sub DESTROY {
|
|
1166 |
+ return unless $_[0]->isa('HASH');
|
|
1167 |
+ my $self = tied(%{$_[0]});
|
|
1168 |
+ return unless defined $self; |
|
1169 |
+ delete $ITERATORS{$self};
|
|
1170 |
+ if (exists $OWNER{$self}) {
|
|
1171 |
+ secdbc::delete_profattr_t($self); |
|
1172 |
+ delete $OWNER{$self};
|
|
1173 |
+ } |
|
1174 |
+} |
|
1175 |
+ |
|
1176 |
+sub DISOWN {
|
|
1177 |
+ my $self = shift; |
|
1178 |
+ my $ptr = tied(%$self); |
|
1179 |
+ delete $OWNER{$ptr};
|
|
1180 |
+} |
|
1181 |
+ |
|
1182 |
+sub ACQUIRE {
|
|
1183 |
+ my $self = shift; |
|
1184 |
+ my $ptr = tied(%$self); |
|
1185 |
+ $OWNER{$ptr} = 1;
|
|
1186 |
+} |
|
1187 |
+ |
|
1188 |
+ |
|
1189 |
+############# Class : secdb::userstr_t ############## |
|
1190 |
+ |
|
1191 |
+package secdb::userstr_t; |
|
1192 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1193 |
+@ISA = qw( secdb ); |
|
1194 |
+%OWNER = (); |
|
1195 |
+%ITERATORS = (); |
|
1196 |
+*swig_name_get = *secdbc::userstr_t_name_get; |
|
1197 |
+*swig_name_set = *secdbc::userstr_t_name_set; |
|
1198 |
+*swig_qualifier_get = *secdbc::userstr_t_qualifier_get; |
|
1199 |
+*swig_qualifier_set = *secdbc::userstr_t_qualifier_set; |
|
1200 |
+*swig_res1_get = *secdbc::userstr_t_res1_get; |
|
1201 |
+*swig_res1_set = *secdbc::userstr_t_res1_set; |
|
1202 |
+*swig_res2_get = *secdbc::userstr_t_res2_get; |
|
1203 |
+*swig_res2_set = *secdbc::userstr_t_res2_set; |
|
1204 |
+*swig_attr_get = *secdbc::userstr_t_attr_get; |
|
1205 |
+*swig_attr_set = *secdbc::userstr_t_attr_set; |
|
1206 |
+sub new {
|
|
1207 |
+ my $pkg = shift; |
|
1208 |
+ my $self = secdbc::new_userstr_t(@_); |
|
1209 |
+ bless $self, $pkg if defined($self); |
|
1210 |
+} |
|
1211 |
+ |
|
1212 |
+sub DESTROY {
|
|
1213 |
+ return unless $_[0]->isa('HASH');
|
|
1214 |
+ my $self = tied(%{$_[0]});
|
|
1215 |
+ return unless defined $self; |
|
1216 |
+ delete $ITERATORS{$self};
|
|
1217 |
+ if (exists $OWNER{$self}) {
|
|
1218 |
+ secdbc::delete_userstr_t($self); |
|
1219 |
+ delete $OWNER{$self};
|
|
1220 |
+ } |
|
1221 |
+} |
|
1222 |
+ |
|
1223 |
+sub DISOWN {
|
|
1224 |
+ my $self = shift; |
|
1225 |
+ my $ptr = tied(%$self); |
|
1226 |
+ delete $OWNER{$ptr};
|
|
1227 |
+} |
|
1228 |
+ |
|
1229 |
+sub ACQUIRE {
|
|
1230 |
+ my $self = shift; |
|
1231 |
+ my $ptr = tied(%$self); |
|
1232 |
+ $OWNER{$ptr} = 1;
|
|
1233 |
+} |
|
1234 |
+ |
|
1235 |
+ |
|
1236 |
+############# Class : secdb::userattr_t ############## |
|
1237 |
+ |
|
1238 |
+package secdb::userattr_t; |
|
1239 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1240 |
+@ISA = qw( secdb ); |
|
1241 |
+%OWNER = (); |
|
1242 |
+%ITERATORS = (); |
|
1243 |
+*swig_name_get = *secdbc::userattr_t_name_get; |
|
1244 |
+*swig_name_set = *secdbc::userattr_t_name_set; |
|
1245 |
+*swig_qualifier_get = *secdbc::userattr_t_qualifier_get; |
|
1246 |
+*swig_qualifier_set = *secdbc::userattr_t_qualifier_set; |
|
1247 |
+*swig_res1_get = *secdbc::userattr_t_res1_get; |
|
1248 |
+*swig_res1_set = *secdbc::userattr_t_res1_set; |
|
1249 |
+*swig_res2_get = *secdbc::userattr_t_res2_get; |
|
1250 |
+*swig_res2_set = *secdbc::userattr_t_res2_set; |
|
1251 |
+*swig_attr_get = *secdbc::userattr_t_attr_get; |
|
1252 |
+*swig_attr_set = *secdbc::userattr_t_attr_set; |
|
1253 |
+sub new {
|
|
1254 |
+ my $pkg = shift; |
|
1255 |
+ my $self = secdbc::new_userattr_t(@_); |
|
1256 |
+ bless $self, $pkg if defined($self); |
|
1257 |
+} |
|
1258 |
+ |
|
1259 |
+sub DESTROY {
|
|
1260 |
+ return unless $_[0]->isa('HASH');
|
|
1261 |
+ my $self = tied(%{$_[0]});
|
|
1262 |
+ return unless defined $self; |
|
1263 |
+ delete $ITERATORS{$self};
|
|
1264 |
+ if (exists $OWNER{$self}) {
|
|
1265 |
+ secdbc::delete_userattr_t($self); |
|
1266 |
+ delete $OWNER{$self};
|
|
1267 |
+ } |
|
1268 |
+} |
|
1269 |
+ |
|
1270 |
+sub DISOWN {
|
|
1271 |
+ my $self = shift; |
|
1272 |
+ my $ptr = tied(%$self); |
|
1273 |
+ delete $OWNER{$ptr};
|
|
1274 |
+} |
|
1275 |
+ |
|
1276 |
+sub ACQUIRE {
|
|
1277 |
+ my $self = shift; |
|
1278 |
+ my $ptr = tied(%$self); |
|
1279 |
+ $OWNER{$ptr} = 1;
|
|
1280 |
+} |
|
1281 |
+ |
|
1282 |
+ |
|
1283 |
+############# Class : secdb::kv_t ############## |
|
1284 |
+ |
|
1285 |
+package secdb::kv_t; |
|
1286 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1287 |
+@ISA = qw( secdb ); |
|
1288 |
+%OWNER = (); |
|
1289 |
+%ITERATORS = (); |
|
1290 |
+*swig_key_get = *secdbc::kv_t_key_get; |
|
1291 |
+*swig_key_set = *secdbc::kv_t_key_set; |
|
1292 |
+*swig_value_get = *secdbc::kv_t_value_get; |
|
1293 |
+*swig_value_set = *secdbc::kv_t_value_set; |
|
1294 |
+sub new {
|
|
1295 |
+ my $pkg = shift; |
|
1296 |
+ my $self = secdbc::new_kv_t(@_); |
|
1297 |
+ bless $self, $pkg if defined($self); |
|
1298 |
+} |
|
1299 |
+ |
|
1300 |
+sub DESTROY {
|
|
1301 |
+ return unless $_[0]->isa('HASH');
|
|
1302 |
+ my $self = tied(%{$_[0]});
|
|
1303 |
+ return unless defined $self; |
|
1304 |
+ delete $ITERATORS{$self};
|
|
1305 |
+ if (exists $OWNER{$self}) {
|
|
1306 |
+ secdbc::delete_kv_t($self); |
|
1307 |
+ delete $OWNER{$self};
|
|
1308 |
+ } |
|
1309 |
+} |
|
1310 |
+ |
|
1311 |
+sub DISOWN {
|
|
1312 |
+ my $self = shift; |
|
1313 |
+ my $ptr = tied(%$self); |
|
1314 |
+ delete $OWNER{$ptr};
|
|
1315 |
+} |
|
1316 |
+ |
|
1317 |
+sub ACQUIRE {
|
|
1318 |
+ my $self = shift; |
|
1319 |
+ my $ptr = tied(%$self); |
|
1320 |
+ $OWNER{$ptr} = 1;
|
|
1321 |
+} |
|
1322 |
+ |
|
1323 |
+ |
|
1324 |
+############# Class : secdb::kva_t ############## |
|
1325 |
+ |
|
1326 |
+package secdb::kva_t; |
|
1327 |
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS); |
|
1328 |
+@ISA = qw( secdb ); |
|
1329 |
+%OWNER = (); |
|
1330 |
+%ITERATORS = (); |
|
1331 |
+*swig_length_get = *secdbc::kva_t_length_get; |
|
1332 |
+*swig_length_set = *secdbc::kva_t_length_set; |
|
1333 |
+*swig_data_get = *secdbc::kva_t_data_get; |
|
1334 |
+*swig_data_set = *secdbc::kva_t_data_set; |
|
1335 |
+sub new {
|
|
1336 |
+ my $pkg = shift; |
|
1337 |
+ my $self = secdbc::new_kva_t(@_); |
|
1338 |
+ bless $self, $pkg if defined($self); |
|
1339 |
+} |
|
1340 |
+ |
|
1341 |
+sub DESTROY {
|
|
1342 |
+ return unless $_[0]->isa('HASH');
|
|
1343 |
+ my $self = tied(%{$_[0]});
|
|
1344 |
+ return unless defined $self; |
|
1345 |
+ delete $ITERATORS{$self};
|
|
1346 |
+ if (exists $OWNER{$self}) {
|
|
1347 |
+ secdbc::delete_kva_t($self); |
|
1348 |
+ delete $OWNER{$self};
|
|
1349 |
+ } |
|
1350 |
+} |
|
1351 |
+ |
|
1352 |
+sub DISOWN {
|
|
1353 |
+ my $self = shift; |
|
1354 |
+ my $ptr = tied(%$self); |
|
1355 |
+ delete $OWNER{$ptr};
|
|
1356 |
+} |
|
1357 |
+ |
|
1358 |
+sub ACQUIRE {
|
|
1359 |
+ my $self = shift; |
|
1360 |
+ my $ptr = tied(%$self); |
|
1361 |
+ $OWNER{$ptr} = 1;
|
|
1362 |
+} |
|
1363 |
+ |
|
1364 |
+ |
|
1365 |
+# ------- VARIABLE STUBS -------- |
|
1366 |
+ |
|
1367 |
+package secdb; |
|
1368 |
+ |
|
1369 |
+*PROFATTR_FILENAME = *secdbc::PROFATTR_FILENAME; |
|
1370 |
+*PROFATTR_DB_NAME = *secdbc::PROFATTR_DB_NAME; |
|
1371 |
+*PROFATTR_DB_NCOL = *secdbc::PROFATTR_DB_NCOL; |
|
1372 |
+*PROFATTR_DB_NKEYCOL = *secdbc::PROFATTR_DB_NKEYCOL; |
|
1373 |
+*PROFATTR_DB_TBLT = *secdbc::PROFATTR_DB_TBLT; |
|
1374 |
+*PROFATTR_NAME_DEFAULT_KW = *secdbc::PROFATTR_NAME_DEFAULT_KW; |
|
1375 |
+*PROFATTR_COL0_KW = *secdbc::PROFATTR_COL0_KW; |
|
1376 |
+*PROFATTR_COL1_KW = *secdbc::PROFATTR_COL1_KW; |
|
1377 |
+*PROFATTR_COL2_KW = *secdbc::PROFATTR_COL2_KW; |
|
1378 |
+*PROFATTR_COL3_KW = *secdbc::PROFATTR_COL3_KW; |
|
1379 |
+*PROFATTR_COL4_KW = *secdbc::PROFATTR_COL4_KW; |
|
1380 |
+*DEF_PROF = *secdbc::DEF_PROF; |
|
1381 |
+*DEF_CONSUSER = *secdbc::DEF_CONSUSER; |
|
1382 |
+*MAXPROFS = *secdbc::MAXPROFS; |
|
1383 |
+*PROFATTR_KEYCOL0 = *secdbc::PROFATTR_KEYCOL0; |
|
1384 |
+*PROFATTR_AUTHS_KW = *secdbc::PROFATTR_AUTHS_KW; |
|
1385 |
+*PROFATTR_PROFS_KW = *secdbc::PROFATTR_PROFS_KW; |
|
1386 |
+*PROFATTR_PRIVS_KW = *secdbc::PROFATTR_PRIVS_KW; |
|
1387 |
+*USERATTR_FILENAME = *secdbc::USERATTR_FILENAME; |
|
1388 |
+*USERATTR_DB_NAME = *secdbc::USERATTR_DB_NAME; |
|
1389 |
+*USERATTR_DB_NCOL = *secdbc::USERATTR_DB_NCOL; |
|
1390 |
+*USERATTR_DB_NKEYCOL = *secdbc::USERATTR_DB_NKEYCOL; |
|
1391 |
+*USERATTR_DB_TBL = *secdbc::USERATTR_DB_TBL; |
|
1392 |
+*USERATTR_NAME_DEFAULT_KW = *secdbc::USERATTR_NAME_DEFAULT_KW; |
|
1393 |
+*USERATTR_COL0_KW = *secdbc::USERATTR_COL0_KW; |
|
1394 |
+*USERATTR_COL1_KW = *secdbc::USERATTR_COL1_KW; |
|
1395 |
+*USERATTR_COL2_KW = *secdbc::USERATTR_COL2_KW; |
|
1396 |
+*USERATTR_COL3_KW = *secdbc::USERATTR_COL3_KW; |
|
1397 |
+*USERATTR_COL4_KW = *secdbc::USERATTR_COL4_KW; |
|
1398 |
+*DEF_LIMITPRIV = *secdbc::DEF_LIMITPRIV; |
|
1399 |
+*DEF_DFLTPRIV = *secdbc::DEF_DFLTPRIV; |
|
1400 |
+*USERATTR_KEYCOL0 = *secdbc::USERATTR_KEYCOL0; |
|
1401 |
+*USERATTR_KEYCOL1 = *secdbc::USERATTR_KEYCOL1; |
|
1402 |
+*USERATTR_LOCK_KW = *secdbc::USERATTR_LOCK_KW; |
|
1403 |
+*USERATTR_LOCK_LOCKED_KW = *secdbc::USERATTR_LOCK_LOCKED_KW; |
|
1404 |
+*USERATTR_LOCK_OPEN_KW = *secdbc::USERATTR_LOCK_OPEN_KW; |
|
1405 |
+*USERATTR_LOCK_FIXED_KW = *secdbc::USERATTR_LOCK_FIXED_KW; |
|
1406 |
+*USERATTR_GEN_KW = *secdbc::USERATTR_GEN_KW; |
|
1407 |
+*USERATTR_GEN_AUTOMATIC_KW = *secdbc::USERATTR_GEN_AUTOMATIC_KW; |
|
1408 |
+*USERATTR_GEN_MANUAL_KW = *secdbc::USERATTR_GEN_MANUAL_KW; |
|
1409 |
+*USERATTR_GEN_SYSDEF_KW = *secdbc::USERATTR_GEN_SYSDEF_KW; |
|
1410 |
+*USERATTR_PROFILES_KW = *secdbc::USERATTR_PROFILES_KW; |
|
1411 |
+*USERATTR_PROFILES_NONE_KW = *secdbc::USERATTR_PROFILES_NONE_KW; |
|
1412 |
+*USERATTR_ROLES_KW = *secdbc::USERATTR_ROLES_KW; |
|
1413 |
+*USERATTR_ROLES_NONE_KW = *secdbc::USERATTR_ROLES_NONE_KW; |
|
1414 |
+*USERATTR_DEFAULTPROJ_KW = *secdbc::USERATTR_DEFAULTPROJ_KW; |
|
1415 |
+*USERATTR_IDLETIME_KW = *secdbc::USERATTR_IDLETIME_KW; |
|
1416 |
+*USERATTR_IDLECMD_KW = *secdbc::USERATTR_IDLECMD_KW; |
|
1417 |
+*USERATTR_IDLECMD_LOCK_KW = *secdbc::USERATTR_IDLECMD_LOCK_KW; |
|
1418 |
+*USERATTR_IDLECMD_LOGOUT_KW = *secdbc::USERATTR_IDLECMD_LOGOUT_KW; |
|
1419 |
+*USERATTR_TYPE_KW = *secdbc::USERATTR_TYPE_KW; |
|
1420 |
+*USERATTR_TYPE_NORMAL_KW = *secdbc::USERATTR_TYPE_NORMAL_KW; |
|
1421 |
+*USERATTR_TYPE_ADMIN_KW = *secdbc::USERATTR_TYPE_ADMIN_KW; |
|
1422 |
+*USERATTR_TYPE_NONADMIN_KW = *secdbc::USERATTR_TYPE_NONADMIN_KW; |
|
1423 |
+*USERATTR_AUTHS_KW = *secdbc::USERATTR_AUTHS_KW; |
|
1424 |
+*USERATTR_LIMPRIV_KW = *secdbc::USERATTR_LIMPRIV_KW; |
|
1425 |
+*USERATTR_DFLTPRIV_KW = *secdbc::USERATTR_DFLTPRIV_KW; |
|
1426 |
+*USERATTR_LOCK_AFTER_RETRIES_KW = *secdbc::USERATTR_LOCK_AFTER_RETRIES_KW; |
|
1427 |
+*USERATTR_CLEARANCE = *secdbc::USERATTR_CLEARANCE; |
|
1428 |
+*USERATTR_LABELVIEW = *secdbc::USERATTR_LABELVIEW; |
|
1429 |
+*USERATTR_LABELVIEW_EXTERNAL = *secdbc::USERATTR_LABELVIEW_EXTERNAL; |
|
1430 |
+*USERATTR_LABELVIEW_HIDESL = *secdbc::USERATTR_LABELVIEW_HIDESL; |
|
1431 |
+*USERATTR_HIDESL = *secdbc::USERATTR_HIDESL; |
|
1432 |
+*USERATTR_LABELVIEW_INTERNAL = *secdbc::USERATTR_LABELVIEW_INTERNAL; |
|
1433 |
+*USERATTR_LABELVIEW_SHOWSL = *secdbc::USERATTR_LABELVIEW_SHOWSL; |
|
1434 |
+*USERATTR_LABELTRANS = *secdbc::USERATTR_LABELTRANS; |
|
1435 |
+*USERATTR_LOCK_NO = *secdbc::USERATTR_LOCK_NO; |
|
1436 |
+*USERATTR_LOCK_YES = *secdbc::USERATTR_LOCK_YES; |
|
1437 |
+*USERATTR_MINLABEL = *secdbc::USERATTR_MINLABEL; |
|
1438 |
+*USERATTR_PASSWD = *secdbc::USERATTR_PASSWD; |
|
1439 |
+*USERATTR_PASSWD_AUTOMATIC = *secdbc::USERATTR_PASSWD_AUTOMATIC; |
|
1440 |
+*USERATTR_PASSWD_MANUAL = *secdbc::USERATTR_PASSWD_MANUAL; |
|
1441 |
+*USERATTR_TYPE_ROLE = *secdbc::USERATTR_TYPE_ROLE; |
|
1442 |
+*DEFAULT_POLICY = *secdbc::DEFAULT_POLICY; |
|
1443 |
+*SUSER_POLICY = *secdbc::SUSER_POLICY; |
|
1444 |
+*KV_ACTION = *secdbc::KV_ACTION; |
|
1445 |
+*KV_COMMAND = *secdbc::KV_COMMAND; |
|
1446 |
+*KV_JAVA_CLASS = *secdbc::KV_JAVA_CLASS; |
|
1447 |
+*KV_JAVA_METHOD = *secdbc::KV_JAVA_METHOD; |
|
1448 |
+*KV_ASSIGN = *secdbc::KV_ASSIGN; |
|
1449 |
+*KV_DELIMITER = *secdbc::KV_DELIMITER; |
|
1450 |
+*KV_EMPTY = *secdbc::KV_EMPTY; |
|
1451 |
+*KV_ESCAPE = *secdbc::KV_ESCAPE; |
|
1452 |
+*KV_ADD_KEYS = *secdbc::KV_ADD_KEYS; |
|
1453 |
+*KV_SPECIAL = *secdbc::KV_SPECIAL; |
|
1454 |
+*KV_TOKEN_DELIMIT = *secdbc::KV_TOKEN_DELIMIT; |
|
1455 |
+*KV_WILDCARD = *secdbc::KV_WILDCARD; |
|
1456 |
+*KV_WILDCHAR = *secdbc::KV_WILDCHAR; |
|
1457 |
+*KV_ACTION_WILDCARD = *secdbc::KV_ACTION_WILDCARD; |
|
1458 |
+*KV_FLAG_NONE = *secdbc::KV_FLAG_NONE; |
|
1459 |
+*KV_FLAG_REQUIRED = *secdbc::KV_FLAG_REQUIRED; |
|
1460 |
+*ATTR_FOUND = *secdbc::ATTR_FOUND; |
|
1461 |
+*ATTR_NOT_FOUND = *secdbc::ATTR_NOT_FOUND; |
|
1462 |
+*ATTR_NO_RECOVERY = *secdbc::ATTR_NO_RECOVERY; |
|
1463 |
+1; |
|
| 20005 | 1464 |
--- system-tools-backends-1.4.2/secdb_wrap.c 1970-01-01 10:00:00.000000000 +1000 |
1465 |
+++ system-tools-backends-1.4.2.new/secdb_wrap.c 2010-08-05 16:30:19.199811777 +1000 |
|
1466 |
@@ -0,0 +1,5442 @@ |
|
| 15698 | 1467 |
+/* ---------------------------------------------------------------------------- |
1468 |
+ * This file was automatically generated by SWIG (http://www.swig.org). |
|
1469 |
+ * Version 1.3.35 |
|
1470 |
+ * |
|
1471 |
+ * This file is not intended to be easily readable and contains a number of |
|
1472 |
+ * coding conventions designed to improve portability and efficiency. Do not make |
|
1473 |
+ * changes to this file unless you know what you are doing--modify the SWIG |
|
1474 |
+ * interface file instead. |
|
1475 |
+ * ----------------------------------------------------------------------------- */ |
|
1476 |
+ |
|
1477 |
+#define SWIGPERL |
|
1478 |
+#define SWIG_CASTRANK_MODE |
|
1479 |
+/* ----------------------------------------------------------------------------- |
|
1480 |
+ * This section contains generic SWIG labels for method/variable |
|
1481 |
+ * declarations/attributes, and other compiler dependent labels. |
|
1482 |
+ * ----------------------------------------------------------------------------- */ |
|
1483 |
+ |
|
1484 |
+/* template workaround for compilers that cannot correctly implement the C++ standard */ |
|
1485 |
+#ifndef SWIGTEMPLATEDISAMBIGUATOR |
|
1486 |
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) |
|
1487 |
+# define SWIGTEMPLATEDISAMBIGUATOR template |
|
1488 |
+# elif defined(__HP_aCC) |
|
1489 |
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ |
|
1490 |
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ |
|
1491 |
+# define SWIGTEMPLATEDISAMBIGUATOR template |
|
1492 |
+# else |
|
1493 |
+# define SWIGTEMPLATEDISAMBIGUATOR |
|
1494 |
+# endif |
|
1495 |
+#endif |
|
1496 |
+ |
|
1497 |
+/* inline attribute */ |
|
1498 |
+#ifndef SWIGINLINE |
|
1499 |
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) |
|
1500 |
+# define SWIGINLINE inline |
|
1501 |
+# else |
|
1502 |
+# define SWIGINLINE |
|
1503 |
+# endif |
|
1504 |
+#endif |
|
1505 |
+ |
|
1506 |
+/* attribute recognised by some compilers to avoid 'unused' warnings */ |
|
1507 |
+#ifndef SWIGUNUSED |
|
1508 |
+# if defined(__GNUC__) |
|
1509 |
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) |
|
1510 |
+# define SWIGUNUSED __attribute__ ((__unused__)) |
|
1511 |
+# else |
|
1512 |
+# define SWIGUNUSED |
|
1513 |
+# endif |
|
1514 |
+# elif defined(__ICC) |
|
1515 |
+# define SWIGUNUSED __attribute__ ((__unused__)) |
|
1516 |
+# else |
|
1517 |
+# define SWIGUNUSED |
|
1518 |
+# endif |
|
1519 |
+#endif |
|
1520 |
+ |
|
1521 |
+#ifndef SWIGUNUSEDPARM |
|
1522 |
+# ifdef __cplusplus |
|
1523 |
+# define SWIGUNUSEDPARM(p) |
|
1524 |
+# else |
|
1525 |
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED |
|
1526 |
+# endif |
|
1527 |
+#endif |
|
1528 |
+ |
|
1529 |
+/* internal SWIG method */ |
|
1530 |
+#ifndef SWIGINTERN |
|
1531 |
+# define SWIGINTERN static SWIGUNUSED |
|
1532 |
+#endif |
|
1533 |
+ |
|
1534 |
+/* internal inline SWIG method */ |
|
1535 |
+#ifndef SWIGINTERNINLINE |
|
1536 |
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE |
|
1537 |
+#endif |
|
1538 |
+ |
|
1539 |
+/* exporting methods */ |
|
1540 |
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) |
|
1541 |
+# ifndef GCC_HASCLASSVISIBILITY |
|
1542 |
+# define GCC_HASCLASSVISIBILITY |
|
1543 |
+# endif |
|
1544 |
+#endif |
|
1545 |
+ |
|
1546 |
+#ifndef SWIGEXPORT |
|
1547 |
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
|
1548 |
+# if defined(STATIC_LINKED) |
|
1549 |
+# define SWIGEXPORT |
|
1550 |
+# else |
|
1551 |
+# define SWIGEXPORT __declspec(dllexport) |
|
1552 |
+# endif |
|
1553 |
+# else |
|
1554 |
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) |
|
1555 |
+# define SWIGEXPORT __attribute__ ((visibility("default")))
|
|
1556 |
+# else |
|
1557 |
+# define SWIGEXPORT |
|
1558 |
+# endif |
|
1559 |
+# endif |
|
1560 |
+#endif |
|
1561 |
+ |
|
1562 |
+/* calling conventions for Windows */ |
|
1563 |
+#ifndef SWIGSTDCALL |
|
1564 |
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
|
1565 |
+# define SWIGSTDCALL __stdcall |
|
1566 |
+# else |
|
1567 |
+# define SWIGSTDCALL |
|
1568 |
+# endif |
|
1569 |
+#endif |
|
1570 |
+ |
|
1571 |
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ |
|
1572 |
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) |
|
1573 |
+# define _CRT_SECURE_NO_DEPRECATE |
|
1574 |
+#endif |
|
1575 |
+ |
|
1576 |
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ |
|
1577 |
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) |
|
1578 |
+# define _SCL_SECURE_NO_DEPRECATE |
|
1579 |
+#endif |
|
1580 |
+ |
|
1581 |
+ |
|
1582 |
+/* ----------------------------------------------------------------------------- |
|
1583 |
+ * swigrun.swg |
|
1584 |
+ * |
|
1585 |
+ * This file contains generic CAPI SWIG runtime support for pointer |
|
1586 |
+ * type checking. |
|
1587 |
+ * ----------------------------------------------------------------------------- */ |
|
1588 |
+ |
|
1589 |
+/* This should only be incremented when either the layout of swig_type_info changes, |
|
1590 |
+ or for whatever reason, the runtime changes incompatibly */ |
|
1591 |
+#define SWIG_RUNTIME_VERSION "4" |
|
1592 |
+ |
|
1593 |
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ |
|
1594 |
+#ifdef SWIG_TYPE_TABLE |
|
1595 |
+# define SWIG_QUOTE_STRING(x) #x |
|
1596 |
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) |
|
1597 |
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) |
|
1598 |
+#else |
|
1599 |
+# define SWIG_TYPE_TABLE_NAME |
|
1600 |
+#endif |
|
1601 |
+ |
|
1602 |
+/* |
|
1603 |
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for |
|
1604 |
+ creating a static or dynamic library from the swig runtime code. |
|
1605 |
+ In 99.9% of the cases, swig just needs to declare them as 'static'. |
|
1606 |
+ |
|
1607 |
+ But only do this if is strictly necessary, ie, if you have problems |
|
1608 |
+ with your compiler or so. |
|
1609 |
+*/ |
|
1610 |
+ |
|
1611 |
+#ifndef SWIGRUNTIME |
|
1612 |
+# define SWIGRUNTIME SWIGINTERN |
|
1613 |
+#endif |
|
1614 |
+ |
|
1615 |
+#ifndef SWIGRUNTIMEINLINE |
|
1616 |
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE |
|
1617 |
+#endif |
|
1618 |
+ |
|
1619 |
+/* Generic buffer size */ |
|
1620 |
+#ifndef SWIG_BUFFER_SIZE |
|
1621 |
+# define SWIG_BUFFER_SIZE 1024 |
|
1622 |
+#endif |
|
1623 |
+ |
|
1624 |
+/* Flags for pointer conversions */ |
|
1625 |
+#define SWIG_POINTER_DISOWN 0x1 |
|
1626 |
+#define SWIG_CAST_NEW_MEMORY 0x2 |
|
1627 |
+ |
|
1628 |
+/* Flags for new pointer objects */ |
|
1629 |
+#define SWIG_POINTER_OWN 0x1 |
|
1630 |
+ |
|
1631 |
+ |
|
1632 |
+/* |
|
1633 |
+ Flags/methods for returning states. |
|
1634 |
+ |
|
1635 |
+ The swig conversion methods, as ConvertPtr, return and integer |
|
1636 |
+ that tells if the conversion was successful or not. And if not, |
|
1637 |
+ an error code can be returned (see swigerrors.swg for the codes). |
|
1638 |
+ |
|
1639 |
+ Use the following macros/flags to set or process the returning |
|
1640 |
+ states. |
|
1641 |
+ |
|
1642 |
+ In old swig versions, you usually write code as: |
|
1643 |
+ |
|
1644 |
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
|
|
1645 |
+ // success code |
|
1646 |
+ } else {
|
|
1647 |
+ //fail code |
|
1648 |
+ } |
|
1649 |
+ |
|
1650 |
+ Now you can be more explicit as: |
|
1651 |
+ |
|
1652 |
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags); |
|
1653 |
+ if (SWIG_IsOK(res)) {
|
|
1654 |
+ // success code |
|
1655 |
+ } else {
|
|
1656 |
+ // fail code |
|
1657 |
+ } |
|
1658 |
+ |
|
1659 |
+ that seems to be the same, but now you can also do |
|
1660 |
+ |
|
1661 |
+ Type *ptr; |
|
1662 |
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); |
|
1663 |
+ if (SWIG_IsOK(res)) {
|
|
1664 |
+ // success code |
|
1665 |
+ if (SWIG_IsNewObj(res) {
|
|
1666 |
+ ... |
|
1667 |
+ delete *ptr; |
|
1668 |
+ } else {
|
|
1669 |
+ ... |
|
1670 |
+ } |
|
1671 |
+ } else {
|
|
1672 |
+ // fail code |
|
1673 |
+ } |
|
1674 |
+ |
|
1675 |
+ I.e., now SWIG_ConvertPtr can return new objects and you can |
|
1676 |
+ identify the case and take care of the deallocation. Of course that |
|
1677 |
+ requires also to SWIG_ConvertPtr to return new result values, as |
|
1678 |
+ |
|
1679 |
+ int SWIG_ConvertPtr(obj, ptr,...) {
|
|
1680 |
+ if (<obj is ok>) {
|
|
1681 |
+ if (<need new object>) {
|
|
1682 |
+ *ptr = <ptr to new allocated object>; |
|
1683 |
+ return SWIG_NEWOBJ; |
|
1684 |
+ } else {
|
|
1685 |
+ *ptr = <ptr to old object>; |
|
1686 |
+ return SWIG_OLDOBJ; |
|
1687 |
+ } |
|
1688 |
+ } else {
|
|
1689 |
+ return SWIG_BADOBJ; |
|
1690 |
+ } |
|
1691 |
+ } |
|
1692 |
+ |
|
1693 |
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be |
|
1694 |
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the |
|
1695 |
+ swig errors code. |
|
1696 |
+ |
|
1697 |
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code |
|
1698 |
+ allows to return the 'cast rank', for example, if you have this |
|
1699 |
+ |
|
1700 |
+ int food(double) |
|
1701 |
+ int fooi(int); |
|
1702 |
+ |
|
1703 |
+ and you call |
|
1704 |
+ |
|
1705 |
+ food(1) // cast rank '1' (1 -> 1.0) |
|
1706 |
+ fooi(1) // cast rank '0' |
|
1707 |
+ |
|
1708 |
+ just use the SWIG_AddCast()/SWIG_CheckState() |
|
1709 |
+ |
|
1710 |
+ |
|
1711 |
+ */ |
|
1712 |
+#define SWIG_OK (0) |
|
1713 |
+#define SWIG_ERROR (-1) |
|
1714 |
+#define SWIG_IsOK(r) (r >= 0) |
|
1715 |
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) |
|
1716 |
+ |
|
1717 |
+/* The CastRankLimit says how many bits are used for the cast rank */ |
|
1718 |
+#define SWIG_CASTRANKLIMIT (1 << 8) |
|
1719 |
+/* The NewMask denotes the object was created (using new/malloc) */ |
|
1720 |
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) |
|
1721 |
+/* The TmpMask is for in/out typemaps that use temporal objects */ |
|
1722 |
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) |
|
1723 |
+/* Simple returning values */ |
|
1724 |
+#define SWIG_BADOBJ (SWIG_ERROR) |
|
1725 |
+#define SWIG_OLDOBJ (SWIG_OK) |
|
1726 |
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) |
|
1727 |
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) |
|
1728 |
+/* Check, add and del mask methods */ |
|
1729 |
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) |
|
1730 |
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) |
|
1731 |
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) |
|
1732 |
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) |
|
1733 |
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) |
|
1734 |
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) |
|
1735 |
+ |
|
1736 |
+ |
|
1737 |
+/* Cast-Rank Mode */ |
|
1738 |
+#if defined(SWIG_CASTRANK_MODE) |
|
1739 |
+# ifndef SWIG_TypeRank |
|
1740 |
+# define SWIG_TypeRank unsigned long |
|
1741 |
+# endif |
|
1742 |
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ |
|
1743 |
+# define SWIG_MAXCASTRANK (2) |
|
1744 |
+# endif |
|
1745 |
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) |
|
1746 |
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) |
|
1747 |
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
|
|
1748 |
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; |
|
1749 |
+} |
|
1750 |
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
|
|
1751 |
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; |
|
1752 |
+} |
|
1753 |
+#else /* no cast-rank mode */ |
|
1754 |
+# define SWIG_AddCast |
|
1755 |
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) |
|
1756 |
+#endif |
|
1757 |
+ |
|
1758 |
+ |
|
1759 |
+ |
|
1760 |
+ |
|
1761 |
+#include <string.h> |
|
1762 |
+ |
|
1763 |
+#ifdef __cplusplus |
|
1764 |
+extern "C" {
|
|
1765 |
+#endif |
|
1766 |
+ |
|
1767 |
+typedef void *(*swig_converter_func)(void *, int *); |
|
1768 |
+typedef struct swig_type_info *(*swig_dycast_func)(void **); |
|
1769 |
+ |
|
1770 |
+/* Structure to store information on one type */ |
|
1771 |
+typedef struct swig_type_info {
|
|
1772 |
+ const char *name; /* mangled name of this type */ |
|
1773 |
+ const char *str; /* human readable name of this type */ |
|
1774 |
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ |
|
1775 |
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */ |
|
1776 |
+ void *clientdata; /* language specific type data */ |
|
1777 |
+ int owndata; /* flag if the structure owns the clientdata */ |
|
1778 |
+} swig_type_info; |
|
1779 |
+ |
|
1780 |
+/* Structure to store a type and conversion function used for casting */ |
|
1781 |
+typedef struct swig_cast_info {
|
|
1782 |
+ swig_type_info *type; /* pointer to type that is equivalent to this type */ |
|
1783 |
+ swig_converter_func converter; /* function to cast the void pointers */ |
|
1784 |
+ struct swig_cast_info *next; /* pointer to next cast in linked list */ |
|
1785 |
+ struct swig_cast_info *prev; /* pointer to the previous cast */ |
|
1786 |
+} swig_cast_info; |
|
1787 |
+ |
|
1788 |
+/* Structure used to store module information |
|
1789 |
+ * Each module generates one structure like this, and the runtime collects |
|
1790 |
+ * all of these structures and stores them in a circularly linked list.*/ |
|
1791 |
+typedef struct swig_module_info {
|
|
1792 |
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ |
|
1793 |
+ size_t size; /* Number of types in this module */ |
|
1794 |
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */ |
|
1795 |
+ swig_type_info **type_initial; /* Array of initially generated type structures */ |
|
1796 |
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */ |
|
1797 |
+ void *clientdata; /* Language specific module data */ |
|
1798 |
+} swig_module_info; |
|
1799 |
+ |
|
1800 |
+/* |
|
1801 |
+ Compare two type names skipping the space characters, therefore |
|
1802 |
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc. |
|
1803 |
+ |
|
1804 |
+ Return 0 when the two name types are equivalent, as in |
|
1805 |
+ strncmp, but skipping ' '. |
|
1806 |
+*/ |
|
1807 |
+SWIGRUNTIME int |
|
1808 |
+SWIG_TypeNameComp(const char *f1, const char *l1, |
|
1809 |
+ const char *f2, const char *l2) {
|
|
1810 |
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
|
|
1811 |
+ while ((*f1 == ' ') && (f1 != l1)) ++f1; |
|
1812 |
+ while ((*f2 == ' ') && (f2 != l2)) ++f2; |
|
1813 |
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; |
|
1814 |
+ } |
|
1815 |
+ return (int)((l1 - f1) - (l2 - f2)); |
|
1816 |
+} |
|
1817 |
+ |
|
1818 |
+/* |
|
1819 |
+ Check type equivalence in a name list like <name1>|<name2>|... |
|
1820 |
+ Return 0 if not equal, 1 if equal |
|
1821 |
+*/ |
|
1822 |
+SWIGRUNTIME int |
|
1823 |
+SWIG_TypeEquiv(const char *nb, const char *tb) {
|
|
1824 |
+ int equiv = 0; |
|
1825 |
+ const char* te = tb + strlen(tb); |
|
1826 |
+ const char* ne = nb; |
|
1827 |
+ while (!equiv && *ne) {
|
|
1828 |
+ for (nb = ne; *ne; ++ne) {
|
|
1829 |
+ if (*ne == '|') break; |
|
1830 |
+ } |
|
1831 |
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; |
|
1832 |
+ if (*ne) ++ne; |
|
1833 |
+ } |
|
1834 |
+ return equiv; |
|
1835 |
+} |
|
1836 |
+ |
|
1837 |
+/* |
|
1838 |
+ Check type equivalence in a name list like <name1>|<name2>|... |
|
1839 |
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb |
|
1840 |
+*/ |
|
1841 |
+SWIGRUNTIME int |
|
1842 |
+SWIG_TypeCompare(const char *nb, const char *tb) {
|
|
1843 |
+ int equiv = 0; |
|
1844 |
+ const char* te = tb + strlen(tb); |
|
1845 |
+ const char* ne = nb; |
|
1846 |
+ while (!equiv && *ne) {
|
|
1847 |
+ for (nb = ne; *ne; ++ne) {
|
|
1848 |
+ if (*ne == '|') break; |
|
1849 |
+ } |
|
1850 |
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; |
|
1851 |
+ if (*ne) ++ne; |
|
1852 |
+ } |
|
1853 |
+ return equiv; |
|
1854 |
+} |
|
1855 |
+ |
|
1856 |
+ |
|
1857 |
+/* think of this as a c++ template<> or a scheme macro */ |
|
1858 |
+#define SWIG_TypeCheck_Template(comparison, ty) \ |
|
1859 |
+ if (ty) { \
|
|
1860 |
+ swig_cast_info *iter = ty->cast; \ |
|
1861 |
+ while (iter) { \
|
|
1862 |
+ if (comparison) { \
|
|
1863 |
+ if (iter == ty->cast) return iter; \ |
|
1864 |
+ /* Move iter to the top of the linked list */ \ |
|
1865 |
+ iter->prev->next = iter->next; \ |
|
1866 |
+ if (iter->next) \ |
|
1867 |
+ iter->next->prev = iter->prev; \ |
|
1868 |
+ iter->next = ty->cast; \ |
|
1869 |
+ iter->prev = 0; \ |
|
1870 |
+ if (ty->cast) ty->cast->prev = iter; \ |
|
1871 |
+ ty->cast = iter; \ |
|
1872 |
+ return iter; \ |
|
1873 |
+ } \ |
|
1874 |
+ iter = iter->next; \ |
|
1875 |
+ } \ |
|
1876 |
+ } \ |
|
1877 |
+ return 0 |
|
1878 |
+ |
|
1879 |
+/* |
|
1880 |
+ Check the typename |
|
1881 |
+*/ |
|
1882 |
+SWIGRUNTIME swig_cast_info * |
|
1883 |
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
|
|
1884 |
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); |
|
1885 |
+} |
|
1886 |
+ |
|
1887 |
+/* Same as previous function, except strcmp is replaced with a pointer comparison */ |
|
1888 |
+SWIGRUNTIME swig_cast_info * |
|
1889 |
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
|
|
1890 |
+ SWIG_TypeCheck_Template(iter->type == from, into); |
|
1891 |
+} |
|
1892 |
+ |
|
1893 |
+/* |
|
1894 |
+ Cast a pointer up an inheritance hierarchy |
|
1895 |
+*/ |
|
1896 |
+SWIGRUNTIMEINLINE void * |
|
1897 |
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
|
|
1898 |
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); |
|
1899 |
+} |
|
1900 |
+ |
|
1901 |
+/* |
|
1902 |
+ Dynamic pointer casting. Down an inheritance hierarchy |
|
1903 |
+*/ |
|
1904 |
+SWIGRUNTIME swig_type_info * |
|
1905 |
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
|
|
1906 |
+ swig_type_info *lastty = ty; |
|
1907 |
+ if (!ty || !ty->dcast) return ty; |
|
1908 |
+ while (ty && (ty->dcast)) {
|
|
1909 |
+ ty = (*ty->dcast)(ptr); |
|
1910 |
+ if (ty) lastty = ty; |
|
1911 |
+ } |
|
1912 |
+ return lastty; |
|
1913 |
+} |
|
1914 |
+ |
|
1915 |
+/* |
|
1916 |
+ Return the name associated with this type |
|
1917 |
+*/ |
|
1918 |
+SWIGRUNTIMEINLINE const char * |
|
1919 |
+SWIG_TypeName(const swig_type_info *ty) {
|
|
1920 |
+ return ty->name; |
|
1921 |
+} |
|
1922 |
+ |
|
1923 |
+/* |
|
1924 |
+ Return the pretty name associated with this type, |
|
1925 |
+ that is an unmangled type name in a form presentable to the user. |
|
1926 |
+*/ |
|
1927 |
+SWIGRUNTIME const char * |
|
1928 |
+SWIG_TypePrettyName(const swig_type_info *type) {
|
|
1929 |
+ /* The "str" field contains the equivalent pretty names of the |
|
1930 |
+ type, separated by vertical-bar characters. We choose |
|
1931 |
+ to print the last name, as it is often (?) the most |
|
1932 |
+ specific. */ |
|
1933 |
+ if (!type) return NULL; |
|
1934 |
+ if (type->str != NULL) {
|
|
1935 |
+ const char *last_name = type->str; |
|
1936 |
+ const char *s; |
|
1937 |
+ for (s = type->str; *s; s++) |
|
1938 |
+ if (*s == '|') last_name = s+1; |
|
1939 |
+ return last_name; |
|
1940 |
+ } |
|
1941 |
+ else |
|
1942 |
+ return type->name; |
|
1943 |
+} |
|
1944 |
+ |
|
1945 |
+/* |
|
1946 |
+ Set the clientdata field for a type |
|
1947 |
+*/ |
|
1948 |
+SWIGRUNTIME void |
|
1949 |
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
|
|
1950 |
+ swig_cast_info *cast = ti->cast; |
|
1951 |
+ /* if (ti->clientdata == clientdata) return; */ |
|
1952 |
+ ti->clientdata = clientdata; |
|
1953 |
+ |
|
1954 |
+ while (cast) {
|
|
1955 |
+ if (!cast->converter) {
|
|
1956 |
+ swig_type_info *tc = cast->type; |
|
1957 |
+ if (!tc->clientdata) {
|
|
1958 |
+ SWIG_TypeClientData(tc, clientdata); |
|
1959 |
+ } |
|
1960 |
+ } |
|
1961 |
+ cast = cast->next; |
|
1962 |
+ } |
|
1963 |
+} |
|
1964 |
+SWIGRUNTIME void |
|
1965 |
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
|
|
1966 |
+ SWIG_TypeClientData(ti, clientdata); |
|
1967 |
+ ti->owndata = 1; |
|
1968 |
+} |
|
1969 |
+ |
|
1970 |
+/* |
|
1971 |
+ Search for a swig_type_info structure only by mangled name |
|
1972 |
+ Search is a O(log #types) |
|
1973 |
+ |
|
1974 |
+ We start searching at module start, and finish searching when start == end. |
|
1975 |
+ Note: if start == end at the beginning of the function, we go all the way around |
|
1976 |
+ the circular list. |
|
1977 |
+*/ |
|
1978 |
+SWIGRUNTIME swig_type_info * |
|
1979 |
+SWIG_MangledTypeQueryModule(swig_module_info *start, |
|
1980 |
+ swig_module_info *end, |
|
1981 |
+ const char *name) {
|
|
1982 |
+ swig_module_info *iter = start; |
|
1983 |
+ do {
|
|
1984 |
+ if (iter->size) {
|
|
1985 |
+ register size_t l = 0; |
|
1986 |
+ register size_t r = iter->size - 1; |
|
1987 |
+ do {
|
|
1988 |
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */ |
|
1989 |
+ register size_t i = (l + r) >> 1; |
|
1990 |
+ const char *iname = iter->types[i]->name; |
|
1991 |
+ if (iname) {
|
|
1992 |
+ register int compare = strcmp(name, iname); |
|
1993 |
+ if (compare == 0) {
|
|
1994 |
+ return iter->types[i]; |
|
1995 |
+ } else if (compare < 0) {
|
|
1996 |
+ if (i) {
|
|
1997 |
+ r = i - 1; |
|
1998 |
+ } else {
|
|
1999 |
+ break; |
|
2000 |
+ } |
|
2001 |
+ } else if (compare > 0) {
|
|
2002 |
+ l = i + 1; |
|
2003 |
+ } |
|
2004 |
+ } else {
|
|
2005 |
+ break; /* should never happen */ |
|
2006 |
+ } |
|
2007 |
+ } while (l <= r); |
|
2008 |
+ } |
|
2009 |
+ iter = iter->next; |
|
2010 |
+ } while (iter != end); |
|
2011 |
+ return 0; |
|
2012 |
+} |
|
2013 |
+ |
|
2014 |
+/* |
|
2015 |
+ Search for a swig_type_info structure for either a mangled name or a human readable name. |
|
2016 |
+ It first searches the mangled names of the types, which is a O(log #types) |
|
2017 |
+ If a type is not found it then searches the human readable names, which is O(#types). |
|
2018 |
+ |
|
2019 |
+ We start searching at module start, and finish searching when start == end. |
|
2020 |
+ Note: if start == end at the beginning of the function, we go all the way around |
|
2021 |
+ the circular list. |
|
2022 |
+*/ |
|
2023 |
+SWIGRUNTIME swig_type_info * |
|
2024 |
+SWIG_TypeQueryModule(swig_module_info *start, |
|
2025 |
+ swig_module_info *end, |
|
2026 |
+ const char *name) {
|
|
2027 |
+ /* STEP 1: Search the name field using binary search */ |
|
2028 |
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); |
|
2029 |
+ if (ret) {
|
|
2030 |
+ return ret; |
|
2031 |
+ } else {
|
|
2032 |
+ /* STEP 2: If the type hasn't been found, do a complete search |
|
2033 |
+ of the str field (the human readable name) */ |
|
2034 |
+ swig_module_info *iter = start; |
|
2035 |
+ do {
|
|
2036 |
+ register size_t i = 0; |
|
2037 |
+ for (; i < iter->size; ++i) {
|
|
2038 |
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) |
|
2039 |
+ return iter->types[i]; |
|
2040 |
+ } |
|
2041 |
+ iter = iter->next; |
|
2042 |
+ } while (iter != end); |
|
2043 |
+ } |
|
2044 |
+ |
|
2045 |
+ /* neither found a match */ |
|
2046 |
+ return 0; |
|
2047 |
+} |
|
2048 |
+ |
|
2049 |
+/* |
|
2050 |
+ Pack binary data into a string |
|
2051 |
+*/ |
|
2052 |
+SWIGRUNTIME char * |
|
2053 |
+SWIG_PackData(char *c, void *ptr, size_t sz) {
|
|
2054 |
+ static const char hex[17] = "0123456789abcdef"; |
|
2055 |
+ register const unsigned char *u = (unsigned char *) ptr; |
|
2056 |
+ register const unsigned char *eu = u + sz; |
|
2057 |
+ for (; u != eu; ++u) {
|
|
2058 |
+ register unsigned char uu = *u; |
|
2059 |
+ *(c++) = hex[(uu & 0xf0) >> 4]; |
|
2060 |
+ *(c++) = hex[uu & 0xf]; |
|
2061 |
+ } |
|
2062 |
+ return c; |
|
2063 |
+} |
|
2064 |
+ |
|
2065 |
+/* |
|
2066 |
+ Unpack binary data from a string |
|
2067 |
+*/ |
|
2068 |
+SWIGRUNTIME const char * |
|
2069 |
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|
2070 |
+ register unsigned char *u = (unsigned char *) ptr; |
|
2071 |
+ register const unsigned char *eu = u + sz; |
|
2072 |
+ for (; u != eu; ++u) {
|
|
2073 |
+ register char d = *(c++); |
|
2074 |
+ register unsigned char uu; |
|
2075 |
+ if ((d >= '0') && (d <= '9')) |
|
2076 |
+ uu = ((d - '0') << 4); |
|
2077 |
+ else if ((d >= 'a') && (d <= 'f')) |
|
2078 |
+ uu = ((d - ('a'-10)) << 4);
|
|
2079 |
+ else |
|
2080 |
+ return (char *) 0; |
|
2081 |
+ d = *(c++); |
|
2082 |
+ if ((d >= '0') && (d <= '9')) |
|
2083 |
+ uu |= (d - '0'); |
|
2084 |
+ else if ((d >= 'a') && (d <= 'f')) |
|
2085 |
+ uu |= (d - ('a'-10));
|
|
2086 |
+ else |
|
2087 |
+ return (char *) 0; |
|
2088 |
+ *u = uu; |
|
2089 |
+ } |
|
2090 |
+ return c; |
|
2091 |
+} |
|
2092 |
+ |
|
2093 |
+/* |
|
2094 |
+ Pack 'void *' into a string buffer. |
|
2095 |
+*/ |
|
2096 |
+SWIGRUNTIME char * |
|
2097 |
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
|
|
2098 |
+ char *r = buff; |
|
2099 |
+ if ((2*sizeof(void *) + 2) > bsz) return 0; |
|
2100 |
+ *(r++) = '_'; |
|
2101 |
+ r = SWIG_PackData(r,&ptr,sizeof(void *)); |
|
2102 |
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0; |
|
2103 |
+ strcpy(r,name); |
|
2104 |
+ return buff; |
|
2105 |
+} |
|
2106 |
+ |
|
2107 |
+SWIGRUNTIME const char * |
|
2108 |
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
|
|
2109 |
+ if (*c != '_') {
|
|
2110 |
+ if (strcmp(c,"NULL") == 0) {
|
|
2111 |
+ *ptr = (void *) 0; |
|
2112 |
+ return name; |
|
2113 |
+ } else {
|
|
2114 |
+ return 0; |
|
2115 |
+ } |
|
2116 |
+ } |
|
2117 |
+ return SWIG_UnpackData(++c,ptr,sizeof(void *)); |
|
2118 |
+} |
|
2119 |
+ |
|
2120 |
+SWIGRUNTIME char * |
|
2121 |
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
|
|
2122 |
+ char *r = buff; |
|
2123 |
+ size_t lname = (name ? strlen(name) : 0); |
|
2124 |
+ if ((2*sz + 2 + lname) > bsz) return 0; |
|
2125 |
+ *(r++) = '_'; |
|
2126 |
+ r = SWIG_PackData(r,ptr,sz); |
|
2127 |
+ if (lname) {
|
|
2128 |
+ strncpy(r,name,lname+1); |
|
2129 |
+ } else {
|
|
2130 |
+ *r = 0; |
|
2131 |
+ } |
|
2132 |
+ return buff; |
|
2133 |
+} |
|
2134 |
+ |
|
2135 |
+SWIGRUNTIME const char * |
|
2136 |
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
|
|
2137 |
+ if (*c != '_') {
|
|
2138 |
+ if (strcmp(c,"NULL") == 0) {
|
|
2139 |
+ memset(ptr,0,sz); |
|
2140 |
+ return name; |
|
2141 |
+ } else {
|
|
2142 |
+ return 0; |
|
2143 |
+ } |
|
2144 |
+ } |
|
2145 |
+ return SWIG_UnpackData(++c,ptr,sz); |
|
2146 |
+} |
|
2147 |
+ |
|
2148 |
+#ifdef __cplusplus |
|
2149 |
+} |
|
2150 |
+#endif |
|
2151 |
+ |
|
2152 |
+/* Errors in SWIG */ |
|
2153 |
+#define SWIG_UnknownError -1 |
|
2154 |
+#define SWIG_IOError -2 |
|
2155 |
+#define SWIG_RuntimeError -3 |
|
2156 |
+#define SWIG_IndexError -4 |
|
2157 |
+#define SWIG_TypeError -5 |
|
2158 |
+#define SWIG_DivisionByZero -6 |
|
2159 |
+#define SWIG_OverflowError -7 |
|
2160 |
+#define SWIG_SyntaxError -8 |
|
2161 |
+#define SWIG_ValueError -9 |
|
2162 |
+#define SWIG_SystemError -10 |
|
2163 |
+#define SWIG_AttributeError -11 |
|
2164 |
+#define SWIG_MemoryError -12 |
|
2165 |
+#define SWIG_NullReferenceError -13 |
|
2166 |
+ |
|
2167 |
+ |
|
2168 |
+ |
|
2169 |
+#ifdef __cplusplus |
|
2170 |
+/* Needed on some windows machines---since MS plays funny games with the header files under C++ */ |
|
2171 |
+#include <math.h> |
|
2172 |
+#include <stdlib.h> |
|
2173 |
+extern "C" {
|
|
2174 |
+#endif |
|
2175 |
+#include "EXTERN.h" |
|
2176 |
+#include "perl.h" |
|
2177 |
+#include "XSUB.h" |
|
2178 |
+ |
|
2179 |
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */ |
|
2180 |
+ |
|
2181 |
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */ |
|
2182 |
+#ifndef PERL_REVISION |
|
2183 |
+# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION)) |
|
2184 |
+# define PERL_PATCHLEVEL_H_IMPLICIT |
|
2185 |
+# include <patchlevel.h> |
|
2186 |
+# endif |
|
2187 |
+# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) |
|
2188 |
+# include <could_not_find_Perl_patchlevel.h> |
|
2189 |
+# endif |
|
2190 |
+# ifndef PERL_REVISION |
|
2191 |
+# define PERL_REVISION (5) |
|
2192 |
+# define PERL_VERSION PATCHLEVEL |
|
2193 |
+# define PERL_SUBVERSION SUBVERSION |
|
2194 |
+# endif |
|
2195 |
+#endif |
|
2196 |
+ |
|
2197 |
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE) |
|
2198 |
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh) |
|
2199 |
+#endif |
|
2200 |
+ |
|
2201 |
+#ifndef SvIOK_UV |
|
2202 |
+# define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv))) |
|
2203 |
+#endif |
|
2204 |
+ |
|
2205 |
+#ifndef SvUOK |
|
2206 |
+# define SvUOK(sv) SvIOK_UV(sv) |
|
2207 |
+#endif |
|
2208 |
+ |
|
2209 |
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5))) |
|
2210 |
+# define PL_sv_undef sv_undef |
|
2211 |
+# define PL_na na |
|
2212 |
+# define PL_errgv errgv |
|
2213 |
+# define PL_sv_no sv_no |
|
2214 |
+# define PL_sv_yes sv_yes |
|
2215 |
+# define PL_markstack_ptr markstack_ptr |
|
2216 |
+#endif |
|
2217 |
+ |
|
2218 |
+#ifndef IVSIZE |
|
2219 |
+# ifdef LONGSIZE |
|
2220 |
+# define IVSIZE LONGSIZE |
|
2221 |
+# else |
|
2222 |
+# define IVSIZE 4 /* A bold guess, but the best we can make. */ |
|
2223 |
+# endif |
|
2224 |
+#endif |
|
2225 |
+ |
|
2226 |
+#ifndef INT2PTR |
|
2227 |
+# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) |
|
2228 |
+# define PTRV UV |
|
2229 |
+# define INT2PTR(any,d) (any)(d) |
|
2230 |
+# else |
|
2231 |
+# if PTRSIZE == LONGSIZE |
|
2232 |
+# define PTRV unsigned long |
|
2233 |
+# else |
|
2234 |
+# define PTRV unsigned |
|
2235 |
+# endif |
|
2236 |
+# define INT2PTR(any,d) (any)(PTRV)(d) |
|
2237 |
+# endif |
|
2238 |
+ |
|
2239 |
+# define NUM2PTR(any,d) (any)(PTRV)(d) |
|
2240 |
+# define PTR2IV(p) INT2PTR(IV,p) |
|
2241 |
+# define PTR2UV(p) INT2PTR(UV,p) |
|
2242 |
+# define PTR2NV(p) NUM2PTR(NV,p) |
|
2243 |
+ |
|
2244 |
+# if PTRSIZE == LONGSIZE |
|
2245 |
+# define PTR2ul(p) (unsigned long)(p) |
|
2246 |
+# else |
|
2247 |
+# define PTR2ul(p) INT2PTR(unsigned long,p) |
|
2248 |
+# endif |
|
2249 |
+#endif /* !INT2PTR */ |
|
2250 |
+ |
|
2251 |
+#ifndef SvPV_nolen |
|
2252 |
+# define SvPV_nolen(x) SvPV(x,PL_na) |
|
2253 |
+#endif |
|
2254 |
+ |
|
2255 |
+#ifndef get_sv |
|
2256 |
+# define get_sv perl_get_sv |
|
2257 |
+#endif |
|
2258 |
+ |
|
2259 |
+#ifndef ERRSV |
|
2260 |
+# define ERRSV get_sv("@",FALSE)
|
|
2261 |
+#endif |
|
2262 |
+ |
|
2263 |
+#ifndef pTHX_ |
|
2264 |
+#define pTHX_ |
|
2265 |
+#endif |
|
2266 |
+ |
|
2267 |
+#include <string.h> |
|
2268 |
+#ifdef __cplusplus |
|
2269 |
+} |
|
2270 |
+#endif |
|
2271 |
+ |
|
2272 |
+/* ----------------------------------------------------------------------------- |
|
2273 |
+ * error manipulation |
|
2274 |
+ * ----------------------------------------------------------------------------- */ |
|
2275 |
+ |
|
2276 |
+SWIGINTERN const char* |
|
2277 |
+SWIG_Perl_ErrorType(int code) {
|
|
2278 |
+ const char* type = 0; |
|
2279 |
+ switch(code) {
|
|
2280 |
+ case SWIG_MemoryError: |
|
2281 |
+ type = "MemoryError"; |
|
2282 |
+ break; |
|
2283 |
+ case SWIG_IOError: |
|
2284 |
+ type = "IOError"; |
|
2285 |
+ break; |
|
2286 |
+ case SWIG_RuntimeError: |
|
2287 |
+ type = "RuntimeError"; |
|
2288 |
+ break; |
|
2289 |
+ case SWIG_IndexError: |
|
2290 |
+ type = "IndexError"; |
|
2291 |
+ break; |
|
2292 |
+ case SWIG_TypeError: |
|
2293 |
+ type = "TypeError"; |
|
2294 |
+ break; |
|
2295 |
+ case SWIG_DivisionByZero: |
|
2296 |
+ type = "ZeroDivisionError"; |
|
2297 |
+ break; |
|
2298 |
+ case SWIG_OverflowError: |
|
2299 |
+ type = "OverflowError"; |
|
2300 |
+ break; |
|
2301 |
+ case SWIG_SyntaxError: |
|
2302 |
+ type = "SyntaxError"; |
|
2303 |
+ break; |
|
2304 |
+ case SWIG_ValueError: |
|
2305 |
+ type = "ValueError"; |
|
2306 |
+ break; |
|
2307 |
+ case SWIG_SystemError: |
|
2308 |
+ type = "SystemError"; |
|
2309 |
+ break; |
|
2310 |
+ case SWIG_AttributeError: |
|
2311 |
+ type = "AttributeError"; |
|
2312 |
+ break; |
|
2313 |
+ default: |
|
2314 |
+ type = "RuntimeError"; |
|
2315 |
+ } |
|
2316 |
+ return type; |
|
2317 |
+} |
|
2318 |
+ |
|
2319 |
+ |
|
2320 |
+ |
|
2321 |
+ |
|
2322 |
+/* ----------------------------------------------------------------------------- |
|
2323 |
+ * perlrun.swg |
|
2324 |
+ * |
|
2325 |
+ * This file contains the runtime support for Perl modules |
|
2326 |
+ * and includes code for managing global variables and pointer |
|
2327 |
+ * type checking. |
|
2328 |
+ * ----------------------------------------------------------------------------- */ |
|
2329 |
+ |
|
2330 |
+#ifdef PERL_OBJECT |
|
2331 |
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl), |
|
2332 |
+#define SWIG_PERL_OBJECT_CALL pPerl, |
|
2333 |
+#else |
|
2334 |
+#define SWIG_PERL_OBJECT_DECL |
|
2335 |
+#define SWIG_PERL_OBJECT_CALL |
|
2336 |
+#endif |
|
2337 |
+ |
|
2338 |
+/* Common SWIG API */ |
|
2339 |
+ |
|
2340 |
+/* for raw pointers */ |
|
2341 |
+#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags) |
|
2342 |
+#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags) |
|
2343 |
+ |
|
2344 |
+/* for raw packed data */ |
|
2345 |
+#define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type) |
|
2346 |
+#define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type) |
|
2347 |
+ |
|
2348 |
+/* for class or struct pointers */ |
|
2349 |
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) |
|
2350 |
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) |
|
2351 |
+ |
|
2352 |
+/* for C or C++ function pointers */ |
|
2353 |
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0) |
|
2354 |
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0) |
|
2355 |
+ |
|
2356 |
+/* for C++ member pointers, ie, member methods */ |
|
2357 |
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty) |
|
2358 |
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type) |
|
2359 |
+ |
|
2360 |
+ |
|
2361 |
+/* Runtime API */ |
|
2362 |
+ |
|
2363 |
+#define SWIG_GetModule(clientdata) SWIG_Perl_GetModule() |
|
2364 |
+#define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer) |
|
2365 |
+ |
|
2366 |
+ |
|
2367 |
+/* Error manipulation */ |
|
2368 |
+ |
|
2369 |
+#define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code) |
|
2370 |
+#define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg) |
|
2371 |
+#define SWIG_fail goto fail |
|
2372 |
+ |
|
2373 |
+/* Perl-specific SWIG API */ |
|
2374 |
+ |
|
2375 |
+#define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags) |
|
2376 |
+#define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type) |
|
2377 |
+#define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str) |
|
2378 |
+ |
|
2379 |
+ |
|
2380 |
+#define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1) |
|
2381 |
+#define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1) |
|
2382 |
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2) |
|
2383 |
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2) |
|
2384 |
+ |
|
2385 |
+/* ----------------------------------------------------------------------------- |
|
2386 |
+ * pointers/data manipulation |
|
2387 |
+ * ----------------------------------------------------------------------------- */ |
|
2388 |
+ |
|
2389 |
+/* For backward compatibility only */ |
|
2390 |
+#define SWIG_POINTER_EXCEPTION 0 |
|
2391 |
+ |
|
2392 |
+#ifdef __cplusplus |
|
2393 |
+extern "C" {
|
|
2394 |
+#endif |
|
2395 |
+ |
|
2396 |
+#define SWIG_OWNER SWIG_POINTER_OWN |
|
2397 |
+#define SWIG_SHADOW SWIG_OWNER << 1 |
|
2398 |
+ |
|
2399 |
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL |
|
2400 |
+ |
|
2401 |
+/* SWIG Perl macros */ |
|
2402 |
+ |
|
2403 |
+/* Macro to declare an XS function */ |
|
2404 |
+#ifndef XSPROTO |
|
2405 |
+# define XSPROTO(name) void name(pTHX_ CV* cv) |
|
2406 |
+#endif |
|
2407 |
+ |
|
2408 |
+/* Macro to call an XS function */ |
|
2409 |
+#ifdef PERL_OBJECT |
|
2410 |
+# define SWIG_CALLXS(_name) _name(cv,pPerl) |
|
2411 |
+#else |
|
2412 |
+# ifndef MULTIPLICITY |
|
2413 |
+# define SWIG_CALLXS(_name) _name(cv) |
|
2414 |
+# else |
|
2415 |
+# define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) |
|
2416 |
+# endif |
|
2417 |
+#endif |
|
2418 |
+ |
|
2419 |
+#ifdef PERL_OBJECT |
|
2420 |
+#define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this; |
|
2421 |
+ |
|
2422 |
+#ifdef __cplusplus |
|
2423 |
+extern "C" {
|
|
2424 |
+#endif |
|
2425 |
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *); |
|
2426 |
+#ifdef __cplusplus |
|
2427 |
+} |
|
2428 |
+#endif |
|
2429 |
+ |
|
2430 |
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b) |
|
2431 |
+#define SWIGCLASS_STATIC |
|
2432 |
+ |
|
2433 |
+#else /* PERL_OBJECT */ |
|
2434 |
+ |
|
2435 |
+#define MAGIC_PPERL |
|
2436 |
+#define SWIGCLASS_STATIC static SWIGUNUSED |
|
2437 |
+ |
|
2438 |
+#ifndef MULTIPLICITY |
|
2439 |
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b) |
|
2440 |
+ |
|
2441 |
+#ifdef __cplusplus |
|
2442 |
+extern "C" {
|
|
2443 |
+#endif |
|
2444 |
+typedef int (*SwigMagicFunc)(SV *, MAGIC *); |
|
2445 |
+#ifdef __cplusplus |
|
2446 |
+} |
|
2447 |
+#endif |
|
2448 |
+ |
|
2449 |
+#else /* MULTIPLICITY */ |
|
2450 |
+ |
|
2451 |
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b) |
|
2452 |
+ |
|
2453 |
+#ifdef __cplusplus |
|
2454 |
+extern "C" {
|
|
2455 |
+#endif |
|
2456 |
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *); |
|
2457 |
+#ifdef __cplusplus |
|
2458 |
+} |
|
2459 |
+#endif |
|
2460 |
+ |
|
2461 |
+#endif /* MULTIPLICITY */ |
|
2462 |
+#endif /* PERL_OBJECT */ |
|
2463 |
+ |
|
2464 |
+/* Workaround for bug in perl 5.6.x croak and earlier */ |
|
2465 |
+#if (PERL_VERSION < 8) |
|
2466 |
+# ifdef PERL_OBJECT |
|
2467 |
+# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl) |
|
2468 |
+static void SWIG_Perl_croak_null(CPerlObj *pPerl) |
|
2469 |
+# else |
|
2470 |
+static void SWIG_croak_null() |
|
2471 |
+# endif |
|
2472 |
+{
|
|
2473 |
+ SV *err=ERRSV; |
|
2474 |
+# if (PERL_VERSION < 6) |
|
2475 |
+ croak("%_", err);
|
|
2476 |
+# else |
|
2477 |
+ if (SvOK(err) && !SvROK(err)) croak("%_", err);
|
|
2478 |
+ croak(Nullch); |
|
2479 |
+# endif |
|
2480 |
+} |
|
2481 |
+#else |
|
2482 |
+# define SWIG_croak_null() croak(Nullch) |
|
2483 |
+#endif |
|
2484 |
+ |
|
2485 |
+ |
|
2486 |
+/* |
|
2487 |
+ Define how strict is the cast between strings and integers/doubles |
|
2488 |
+ when overloading between these types occurs. |
|
2489 |
+ |
|
2490 |
+ The default is making it as strict as possible by using SWIG_AddCast |
|
2491 |
+ when needed. |
|
2492 |
+ |
|
2493 |
+ You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to |
|
2494 |
+ disable the SWIG_AddCast, making the casting between string and |
|
2495 |
+ numbers less strict. |
|
2496 |
+ |
|
2497 |
+ In the end, we try to solve the overloading between strings and |
|
2498 |
+ numerical types in the more natural way, but if you can avoid it, |
|
2499 |
+ well, avoid it using %rename, for example. |
|
2500 |
+*/ |
|
2501 |
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM |
|
2502 |
+# ifndef SWIG_PERL_STRICT_STR2NUM |
|
2503 |
+# define SWIG_PERL_STRICT_STR2NUM |
|
2504 |
+# endif |
|
2505 |
+#endif |
|
2506 |
+#ifdef SWIG_PERL_STRICT_STR2NUM |
|
2507 |
+/* string takes precedence */ |
|
2508 |
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x) |
|
2509 |
+#else |
|
2510 |
+/* number takes precedence */ |
|
2511 |
+#define SWIG_Str2NumCast(x) x |
|
2512 |
+#endif |
|
2513 |
+ |
|
2514 |
+ |
|
2515 |
+ |
|
2516 |
+#include <stdlib.h> |
|
2517 |
+ |
|
2518 |
+SWIGRUNTIME const char * |
|
2519 |
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
|
|
2520 |
+ if (!type) return NULL; |
|
2521 |
+ if (type->clientdata != NULL) {
|
|
2522 |
+ return (const char*) type->clientdata; |
|
2523 |
+ } |
|
2524 |
+ else {
|
|
2525 |
+ return type->name; |
|
2526 |
+ } |
|
2527 |
+} |
|
2528 |
+ |
|
2529 |
+SWIGRUNTIME swig_cast_info * |
|
2530 |
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
|
|
2531 |
+ SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) |
|
2532 |
+ || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty); |
|
2533 |
+} |
|
2534 |
+ |
|
2535 |
+ |
|
2536 |
+/* Function for getting a pointer value */ |
|
2537 |
+ |
|
2538 |
+SWIGRUNTIME int |
|
2539 |
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
|
|
2540 |
+ swig_cast_info *tc; |
|
2541 |
+ void *voidptr = (void *)0; |
|
2542 |
+ SV *tsv = 0; |
|
2543 |
+ /* If magical, apply more magic */ |
|
2544 |
+ if (SvGMAGICAL(sv)) |
|
2545 |
+ mg_get(sv); |
|
2546 |
+ |
|
2547 |
+ /* Check to see if this is an object */ |
|
2548 |
+ if (sv_isobject(sv)) {
|
|
2549 |
+ IV tmp = 0; |
|
2550 |
+ tsv = (SV*) SvRV(sv); |
|
2551 |
+ if ((SvTYPE(tsv) == SVt_PVHV)) {
|
|
2552 |
+ MAGIC *mg; |
|
2553 |
+ if (SvMAGICAL(tsv)) {
|
|
2554 |
+ mg = mg_find(tsv,'P'); |
|
2555 |
+ if (mg) {
|
|
2556 |
+ sv = mg->mg_obj; |
|
2557 |
+ if (sv_isobject(sv)) {
|
|
2558 |
+ tsv = (SV*)SvRV(sv); |
|
2559 |
+ tmp = SvIV(tsv); |
|
2560 |
+ } |
|
2561 |
+ } |
|
2562 |
+ } else {
|
|
2563 |
+ return SWIG_ERROR; |
|
2564 |
+ } |
|
2565 |
+ } else {
|
|
2566 |
+ tmp = SvIV(tsv); |
|
2567 |
+ } |
|
2568 |
+ voidptr = INT2PTR(void *,tmp); |
|
2569 |
+ } else if (! SvOK(sv)) { /* Check for undef */
|
|
2570 |
+ *(ptr) = (void *) 0; |
|
2571 |
+ return SWIG_OK; |
|
2572 |
+ } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
|
|
2573 |
+ if (!SvROK(sv)) {
|
|
2574 |
+ *(ptr) = (void *) 0; |
|
2575 |
+ return SWIG_OK; |
|
2576 |
+ } else {
|
|
2577 |
+ return SWIG_ERROR; |
|
2578 |
+ } |
|
2579 |
+ } else { /* Don't know what it is */
|
|
2580 |
+ return SWIG_ERROR; |
|
2581 |
+ } |
|
2582 |
+ if (_t) {
|
|
2583 |
+ /* Now see if the types match */ |
|
2584 |
+ char *_c = HvNAME(SvSTASH(SvRV(sv))); |
|
2585 |
+ tc = SWIG_TypeProxyCheck(_c,_t); |
|
2586 |
+ if (!tc) {
|
|
2587 |
+ return SWIG_ERROR; |
|
2588 |
+ } |
|
2589 |
+ {
|
|
2590 |
+ int newmemory = 0; |
|
2591 |
+ *ptr = SWIG_TypeCast(tc,voidptr,&newmemory); |
|
2592 |
+ assert(!newmemory); /* newmemory handling not yet implemented */ |
|
2593 |
+ } |
|
2594 |
+ } else {
|
|
2595 |
+ *ptr = voidptr; |
|
2596 |
+ } |
|
2597 |
+ |
|
2598 |
+ /* |
|
2599 |
+ * DISOWN implementation: we need a perl guru to check this one. |
|
2600 |
+ */ |
|
2601 |
+ if (tsv && (flags & SWIG_POINTER_DISOWN)) {
|
|
2602 |
+ /* |
|
2603 |
+ * almost copy paste code from below SWIG_POINTER_OWN setting |
|
2604 |
+ */ |
|
2605 |
+ SV *obj = sv; |
|
2606 |
+ HV *stash = SvSTASH(SvRV(obj)); |
|
2607 |
+ GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE); |
|
2608 |
+ if (isGV(gv)) {
|
|
2609 |
+ HV *hv = GvHVn(gv); |
|
2610 |
+ /* |
|
2611 |
+ * To set ownership (see below), a newSViv(1) entry is added. |
|
2612 |
+ * Hence, to remove ownership, we delete the entry. |
|
2613 |
+ */ |
|
2614 |
+ if (hv_exists_ent(hv, obj, 0)) {
|
|
2615 |
+ hv_delete_ent(hv, obj, 0, 0); |
|
2616 |
+ } |
|
2617 |
+ } |
|
2618 |
+ } |
|
2619 |
+ return SWIG_OK; |
|
2620 |
+} |
|
2621 |
+ |
|
2622 |
+SWIGRUNTIME void |
|
2623 |
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
|
|
2624 |
+ if (ptr && (flags & SWIG_SHADOW)) {
|
|
2625 |
+ SV *self; |
|
2626 |
+ SV *obj=newSV(0); |
|
2627 |
+ HV *hash=newHV(); |
|
2628 |
+ HV *stash; |
|
2629 |
+ sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr); |
|
2630 |
+ stash=SvSTASH(SvRV(obj)); |
|
2631 |
+ if (flags & SWIG_POINTER_OWN) {
|
|
2632 |
+ HV *hv; |
|
2633 |
+ GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE); |
|
2634 |
+ if (!isGV(gv)) |
|
2635 |
+ gv_init(gv, stash, "OWNER", 5, FALSE); |
|
2636 |
+ hv=GvHVn(gv); |
|
2637 |
+ hv_store_ent(hv, obj, newSViv(1), 0); |
|
2638 |
+ } |
|
2639 |
+ sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0); |
|
2640 |
+ SvREFCNT_dec(obj); |
|
2641 |
+ self=newRV_noinc((SV *)hash); |
|
2642 |
+ sv_setsv(sv, self); |
|
2643 |
+ SvREFCNT_dec((SV *)self); |
|
2644 |
+ sv_bless(sv, stash); |
|
2645 |
+ } |
|
2646 |
+ else {
|
|
2647 |
+ sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr); |
|
2648 |
+ } |
|
2649 |
+} |
|
2650 |
+ |
|
2651 |
+SWIGRUNTIMEINLINE SV * |
|
2652 |
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
|
|
2653 |
+ SV *result = sv_newmortal(); |
|
2654 |
+ SWIG_MakePtr(result, ptr, t, flags); |
|
2655 |
+ return result; |
|
2656 |
+} |
|
2657 |
+ |
|
2658 |
+SWIGRUNTIME void |
|
2659 |
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
|
|
2660 |
+ char result[1024]; |
|
2661 |
+ char *r = result; |
|
2662 |
+ if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return; |
|
2663 |
+ *(r++) = '_'; |
|
2664 |
+ r = SWIG_PackData(r,ptr,sz); |
|
2665 |
+ strcpy(r,SWIG_Perl_TypeProxyName(type)); |
|
2666 |
+ sv_setpv(sv, result); |
|
2667 |
+} |
|
2668 |
+ |
|
2669 |
+SWIGRUNTIME SV * |
|
2670 |
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
|
|
2671 |
+ SV *result = sv_newmortal(); |
|
2672 |
+ SWIG_Perl_MakePackedObj(result, ptr, sz, type); |
|
2673 |
+ return result; |
|
2674 |
+} |
|
2675 |
+ |
|
2676 |
+/* Convert a packed value value */ |
|
2677 |
+SWIGRUNTIME int |
|
2678 |
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
|
|
2679 |
+ swig_cast_info *tc; |
|
2680 |
+ const char *c = 0; |
|
2681 |
+ |
|
2682 |
+ if ((!obj) || (!SvOK(obj))) return SWIG_ERROR; |
|
2683 |
+ c = SvPV_nolen(obj); |
|
2684 |
+ /* Pointer values must start with leading underscore */ |
|
2685 |
+ if (*c != '_') return SWIG_ERROR; |
|
2686 |
+ c++; |
|
2687 |
+ c = SWIG_UnpackData(c,ptr,sz); |
|
2688 |
+ if (ty) {
|
|
2689 |
+ tc = SWIG_TypeCheck(c,ty); |
|
2690 |
+ if (!tc) return SWIG_ERROR; |
|
2691 |
+ } |
|
2692 |
+ return SWIG_OK; |
|
2693 |
+} |
|
2694 |
+ |
|
2695 |
+ |
|
2696 |
+/* Macros for low-level exception handling */ |
|
2697 |
+#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
|
|
2698 |
+ |
|
2699 |
+ |
|
2700 |
+typedef XSPROTO(SwigPerlWrapper); |
|
2701 |
+typedef SwigPerlWrapper *SwigPerlWrapperPtr; |
|
2702 |
+ |
|
2703 |
+/* Structure for command table */ |
|
2704 |
+typedef struct {
|
|
2705 |
+ const char *name; |
|
2706 |
+ SwigPerlWrapperPtr wrapper; |
|
2707 |
+} swig_command_info; |
|
2708 |
+ |
|
2709 |
+/* Information for constant table */ |
|
2710 |
+ |
|
2711 |
+#define SWIG_INT 1 |
|
2712 |
+#define SWIG_FLOAT 2 |
|
2713 |
+#define SWIG_STRING 3 |
|
2714 |
+#define SWIG_POINTER 4 |
|
2715 |
+#define SWIG_BINARY 5 |
|
2716 |
+ |
|
2717 |
+/* Constant information structure */ |
|
2718 |
+typedef struct swig_constant_info {
|
|
2719 |
+ int type; |
|
2720 |
+ const char *name; |
|
2721 |
+ long lvalue; |
|
2722 |
+ double dvalue; |
|
2723 |
+ void *pvalue; |
|
2724 |
+ swig_type_info **ptype; |
|
2725 |
+} swig_constant_info; |
|
2726 |
+ |
|
2727 |
+ |
|
2728 |
+/* Structure for variable table */ |
|
2729 |
+typedef struct {
|
|
2730 |
+ const char *name; |
|
2731 |
+ SwigMagicFunc set; |
|
2732 |
+ SwigMagicFunc get; |
|
2733 |
+ swig_type_info **type; |
|
2734 |
+} swig_variable_info; |
|
2735 |
+ |
|
2736 |
+/* Magic variable code */ |
|
2737 |
+#ifndef PERL_OBJECT |
|
2738 |
+#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c) |
|
2739 |
+ #ifndef MULTIPLICITY |
|
2740 |
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) |
|
2741 |
+ #else |
|
2742 |
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) |
|
2743 |
+ #endif |
|
2744 |
+#else |
|
2745 |
+# define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c) |
|
2746 |
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) |
|
2747 |
+#endif |
|
2748 |
+{
|
|
2749 |
+ MAGIC *mg; |
|
2750 |
+ sv_magic(sv,sv,'U',(char *) name,strlen(name)); |
|
2751 |
+ mg = mg_find(sv,'U'); |
|
2752 |
+ mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL)); |
|
2753 |
+ mg->mg_virtual->svt_get = (SwigMagicFunc) get; |
|
2754 |
+ mg->mg_virtual->svt_set = (SwigMagicFunc) set; |
|
2755 |
+ mg->mg_virtual->svt_len = 0; |
|
2756 |
+ mg->mg_virtual->svt_clear = 0; |
|
2757 |
+ mg->mg_virtual->svt_free = 0; |
|
2758 |
+} |
|
2759 |
+ |
|
2760 |
+ |
|
2761 |
+SWIGRUNTIME swig_module_info * |
|
2762 |
+SWIG_Perl_GetModule(void) {
|
|
2763 |
+ static void *type_pointer = (void *)0; |
|
2764 |
+ SV *pointer; |
|
2765 |
+ |
|
2766 |
+ /* first check if pointer already created */ |
|
2767 |
+ if (!type_pointer) {
|
|
2768 |
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
|
|
2769 |
+ if (pointer && SvOK(pointer)) {
|
|
2770 |
+ type_pointer = INT2PTR(swig_type_info **, SvIV(pointer)); |
|
2771 |
+ } |
|
2772 |
+ } |
|
2773 |
+ |
|
2774 |
+ return (swig_module_info *) type_pointer; |
|
2775 |
+} |
|
2776 |
+ |
|
2777 |
+SWIGRUNTIME void |
|
2778 |
+SWIG_Perl_SetModule(swig_module_info *module) {
|
|
2779 |
+ SV *pointer; |
|
2780 |
+ |
|
2781 |
+ /* create a new pointer */ |
|
2782 |
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
|
|
2783 |
+ sv_setiv(pointer, PTR2IV(module)); |
|
2784 |
+} |
|
2785 |
+ |
|
2786 |
+#ifdef __cplusplus |
|
2787 |
+} |
|
2788 |
+#endif |
|
2789 |
+ |
|
2790 |
+/* Workaround perl5 global namespace pollution. Note that undefining library |
|
2791 |
+ * functions like fopen will not solve the problem on all platforms as fopen |
|
2792 |
+ * might be a macro on Windows but not necessarily on other operating systems. */ |
|
2793 |
+#ifdef do_open |
|
2794 |
+ #undef do_open |
|
2795 |
+#endif |
|
2796 |
+#ifdef do_close |
|
2797 |
+ #undef do_close |
|
2798 |
+#endif |
|
2799 |
+#ifdef scalar |
|
2800 |
+ #undef scalar |
|
2801 |
+#endif |
|
2802 |
+#ifdef list |
|
2803 |
+ #undef list |
|
2804 |
+#endif |
|
2805 |
+#ifdef apply |
|
2806 |
+ #undef apply |
|
2807 |
+#endif |
|
2808 |
+#ifdef convert |
|
2809 |
+ #undef convert |
|
2810 |
+#endif |
|
2811 |
+#ifdef Error |
|
2812 |
+ #undef Error |
|
2813 |
+#endif |
|
2814 |
+#ifdef form |
|
2815 |
+ #undef form |
|
2816 |
+#endif |
|
2817 |
+#ifdef vform |
|
2818 |
+ #undef vform |
|
2819 |
+#endif |
|
2820 |
+#ifdef LABEL |
|
2821 |
+ #undef LABEL |
|
2822 |
+#endif |
|
2823 |
+#ifdef METHOD |
|
2824 |
+ #undef METHOD |
|
2825 |
+#endif |
|
2826 |
+#ifdef Move |
|
2827 |
+ #undef Move |
|
2828 |
+#endif |
|
2829 |
+#ifdef yylex |
|
2830 |
+ #undef yylex |
|
2831 |
+#endif |
|
2832 |
+#ifdef yyparse |
|
2833 |
+ #undef yyparse |
|
2834 |
+#endif |
|
2835 |
+#ifdef yyerror |
|
2836 |
+ #undef yyerror |
|
2837 |
+#endif |
|
2838 |
+#ifdef invert |
|
2839 |
+ #undef invert |
|
2840 |
+#endif |
|
2841 |
+#ifdef ref |
|
2842 |
+ #undef ref |
|
2843 |
+#endif |
|
2844 |
+#ifdef read |
|
2845 |
+ #undef read |
|
2846 |
+#endif |
|
2847 |
+#ifdef write |
|
2848 |
+ #undef write |
|
2849 |
+#endif |
|
2850 |
+#ifdef eof |
|
2851 |
+ #undef eof |
|
2852 |
+#endif |
|
2853 |
+#ifdef bool |
|
2854 |
+ #undef bool |
|
2855 |
+#endif |
|
2856 |
+#ifdef close |
|
2857 |
+ #undef close |
|
2858 |
+#endif |
|
2859 |
+#ifdef rewind |
|
2860 |
+ #undef rewind |
|
2861 |
+#endif |
|
2862 |
+#ifdef free |
|
2863 |
+ #undef free |
|
2864 |
+#endif |
|
2865 |
+#ifdef malloc |
|
2866 |
+ #undef malloc |
|
2867 |
+#endif |
|
2868 |
+#ifdef calloc |
|
2869 |
+ #undef calloc |
|
2870 |
+#endif |
|
2871 |
+#ifdef Stat |
|
2872 |
+ #undef Stat |
|
2873 |
+#endif |
|
2874 |
+#ifdef check |
|
2875 |
+ #undef check |
|
2876 |
+#endif |
|
2877 |
+#ifdef seekdir |
|
2878 |
+ #undef seekdir |
|
2879 |
+#endif |
|
2880 |
+#ifdef open |
|
2881 |
+ #undef open |
|
2882 |
+#endif |
|
2883 |
+ |
|
2884 |
+ |
|
2885 |
+ |
|
2886 |
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
|
|
2887 |
+ |
|
2888 |
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
|
|
2889 |
+ |
|
2890 |
+ |
|
2891 |
+ |
|
2892 |
+/* -------- TYPES TABLE (BEGIN) -------- */ |
|
2893 |
+ |
|
2894 |
+#define SWIGTYPE_p___FILE swig_types[0] |
|
2895 |
+#define SWIGTYPE_p_char swig_types[1] |
|
2896 |
+#define SWIGTYPE_p_int swig_types[2] |
|
2897 |
+#define SWIGTYPE_p_kv_s swig_types[3] |
|
2898 |
+#define SWIGTYPE_p_kva_s swig_types[4] |
|
2899 |
+#define SWIGTYPE_p_p_char swig_types[5] |
|
2900 |
+#define SWIGTYPE_p_profattr_s swig_types[6] |
|
2901 |
+#define SWIGTYPE_p_profstr_s swig_types[7] |
|
2902 |
+#define SWIGTYPE_p_uid_t swig_types[8] |
|
2903 |
+#define SWIGTYPE_p_userattr_s swig_types[9] |
|
2904 |
+#define SWIGTYPE_p_userstr_s swig_types[10] |
|
2905 |
+static swig_type_info *swig_types[12]; |
|
2906 |
+static swig_module_info swig_module = {swig_types, 11, 0, 0, 0, 0};
|
|
2907 |
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) |
|
2908 |
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) |
|
2909 |
+ |
|
2910 |
+/* -------- TYPES TABLE (END) -------- */ |
|
2911 |
+ |
|
2912 |
+#define SWIG_init boot_secdb |
|
2913 |
+ |
|
2914 |
+#define SWIG_name "secdbc::boot_secdb" |
|
2915 |
+#define SWIG_prefix "secdbc::" |
|
2916 |
+ |
|
2917 |
+#define SWIGVERSION 0x010335 |
|
2918 |
+#define SWIG_VERSION SWIGVERSION |
|
2919 |
+ |
|
2920 |
+ |
|
2921 |
+#define SWIG_as_voidptr(a) (void *)((const void *)(a)) |
|
2922 |
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) |
|
2923 |
+ |
|
2924 |
+ |
|
2925 |
+#ifdef __cplusplus |
|
2926 |
+extern "C" |
|
2927 |
+#endif |
|
2928 |
+#ifndef PERL_OBJECT |
|
2929 |
+#ifndef MULTIPLICITY |
|
2930 |
+SWIGEXPORT void SWIG_init (CV* cv); |
|
2931 |
+#else |
|
2932 |
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv); |
|
2933 |
+#endif |
|
2934 |
+#else |
|
2935 |
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *); |
|
2936 |
+#endif |
|
2937 |
+ |
|
2938 |
+ |
|
2939 |
+#include "prof_attr.h" |
|
2940 |
+#include "secdb.h" |
|
2941 |
+#include "user_attr.h" |
|
2942 |
+ |
|
2943 |
+ |
|
2944 |
+SWIGINTERNINLINE SV * |
|
2945 |
+SWIG_FromCharPtrAndSize(const char* carray, size_t size) |
|
2946 |
+{
|
|
2947 |
+ SV *obj = sv_newmortal(); |
|
2948 |
+ if (carray) {
|
|
2949 |
+ sv_setpvn(obj, carray, size); |
|
2950 |
+ } else {
|
|
2951 |
+ sv_setsv(obj, &PL_sv_undef); |
|
2952 |
+ } |
|
2953 |
+ return obj; |
|
2954 |
+} |
|
2955 |
+ |
|
2956 |
+ |
|
2957 |
+SWIGINTERNINLINE SV * |
|
2958 |
+SWIG_FromCharPtr(const char *cptr) |
|
2959 |
+{
|
|
2960 |
+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); |
|
2961 |
+} |
|
2962 |
+ |
|
2963 |
+ |
|
2964 |
+SWIGINTERNINLINE SV * |
|
2965 |
+SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value) |
|
2966 |
+{
|
|
2967 |
+ SV *obj = sv_newmortal(); |
|
2968 |
+ sv_setiv(obj, (IV) value); |
|
2969 |
+ return obj; |
|
2970 |
+} |
|
2971 |
+ |
|
2972 |
+ |
|
2973 |
+SWIGINTERNINLINE SV * |
|
2974 |
+SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value) |
|
2975 |
+{
|
|
2976 |
+ return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value); |
|
2977 |
+} |
|
2978 |
+ |
|
2979 |
+ |
|
2980 |
+SWIGINTERN swig_type_info* |
|
2981 |
+SWIG_pchar_descriptor(void) |
|
2982 |
+{
|
|
2983 |
+ static int init = 0; |
|
2984 |
+ static swig_type_info* info = 0; |
|
2985 |
+ if (!init) {
|
|
2986 |
+ info = SWIG_TypeQuery("_p_char");
|
|
2987 |
+ init = 1; |
|
2988 |
+ } |
|
2989 |
+ return info; |
|
2990 |
+} |
|
2991 |
+ |
|
2992 |
+ |
|
2993 |
+SWIGINTERN int |
|
2994 |
+SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc) |
|
2995 |
+{
|
|
2996 |
+ if (SvPOK(obj)) {
|
|
2997 |
+ STRLEN len = 0; |
|
2998 |
+ char *cstr = SvPV(obj, len); |
|
2999 |
+ size_t size = len + 1; |
|
3000 |
+ if (cptr) {
|
|
3001 |
+ if (alloc) {
|
|
3002 |
+ if (*alloc == SWIG_NEWOBJ) {
|
|
3003 |
+ *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size)); |
|
3004 |
+ } else {
|
|
3005 |
+ *cptr = cstr; |
|
3006 |
+ *alloc = SWIG_OLDOBJ; |
|
3007 |
+ } |
|
3008 |
+ } |
|
3009 |
+ } |
|
3010 |
+ if (psize) *psize = size; |
|
3011 |
+ return SWIG_OK; |
|
3012 |
+ } else {
|
|
3013 |
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); |
|
3014 |
+ if (pchar_descriptor) {
|
|
3015 |
+ char* vptr = 0; |
|
3016 |
+ if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
|
|
3017 |
+ if (cptr) *cptr = vptr; |
|
3018 |
+ if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0; |
|
3019 |
+ if (alloc) *alloc = SWIG_OLDOBJ; |
|
3020 |
+ return SWIG_OK; |
|
3021 |
+ } |
|
3022 |
+ } |
|
3023 |
+ } |
|
3024 |
+ return SWIG_TypeError; |
|
3025 |
+} |
|
3026 |
+ |
|
3027 |
+ |
|
3028 |
+ |
|
3029 |
+ |
|
3030 |
+ |
|
3031 |
+#include <limits.h> |
|
3032 |
+#if !defined(SWIG_NO_LLONG_MAX) |
|
3033 |
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) |
|
3034 |
+# define LLONG_MAX __LONG_LONG_MAX__ |
|
3035 |
+# define LLONG_MIN (-LLONG_MAX - 1LL) |
|
3036 |
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) |
|
3037 |
+# endif |
|
3038 |
+#endif |
|
3039 |
+ |
|
3040 |
+ |
|
3041 |
+SWIGINTERN int |
|
3042 |
+SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val) |
|
3043 |
+{
|
|
3044 |
+ if (SvNIOK(obj)) {
|
|
3045 |
+ if (val) *val = SvNV(obj); |
|
3046 |
+ return SWIG_OK; |
|
3047 |
+ } else if (SvIOK(obj)) {
|
|
3048 |
+ if (val) *val = (double) SvIV(obj); |
|
3049 |
+ return SWIG_AddCast(SWIG_OK); |
|
3050 |
+ } else {
|
|
3051 |
+ const char *nptr = SvPV_nolen(obj); |
|
3052 |
+ if (nptr) {
|
|
3053 |
+ char *endptr; |
|
3054 |
+ double v = strtod(nptr, &endptr); |
|
3055 |
+ if (errno == ERANGE) {
|
|
3056 |
+ errno = 0; |
|
3057 |
+ return SWIG_OverflowError; |
|
3058 |
+ } else {
|
|
3059 |
+ if (*endptr == '\0') {
|
|
3060 |
+ if (val) *val = v; |
|
3061 |
+ return SWIG_Str2NumCast(SWIG_OK); |
|
3062 |
+ } |
|
3063 |
+ } |
|
3064 |
+ } |
|
3065 |
+ } |
|
3066 |
+ return SWIG_TypeError; |
|
3067 |
+} |
|
3068 |
+ |
|
3069 |
+ |
|
3070 |
+#include <float.h> |
|
3071 |
+ |
|
3072 |
+ |
|
3073 |
+#include <math.h> |
|
3074 |
+ |
|
3075 |
+ |
|
3076 |
+SWIGINTERNINLINE int |
|
3077 |
+SWIG_CanCastAsInteger(double *d, double min, double max) {
|
|
3078 |
+ double x = *d; |
|
3079 |
+ if ((min <= x && x <= max)) {
|
|
3080 |
+ double fx = floor(x); |
|
3081 |
+ double cx = ceil(x); |
|
3082 |
+ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ |
|
3083 |
+ if ((errno == EDOM) || (errno == ERANGE)) {
|
|
3084 |
+ errno = 0; |
|
3085 |
+ } else {
|
|
3086 |
+ double summ, reps, diff; |
|
3087 |
+ if (rd < x) {
|
|
3088 |
+ diff = x - rd; |
|
3089 |
+ } else if (rd > x) {
|
|
3090 |
+ diff = rd - x; |
|
3091 |
+ } else {
|
|
3092 |
+ return 1; |
|
3093 |
+ } |
|
3094 |
+ summ = rd + x; |
|
3095 |
+ reps = diff/summ; |
|
3096 |
+ if (reps < 8*DBL_EPSILON) {
|
|
3097 |
+ *d = rd; |
|
3098 |
+ return 1; |
|
3099 |
+ } |
|
3100 |
+ } |
|
3101 |
+ } |
|
3102 |
+ return 0; |
|
3103 |
+} |
|
3104 |
+ |
|
3105 |
+ |
|
3106 |
+SWIGINTERN int |
|
3107 |
+SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val) |
|
3108 |
+{
|
|
3109 |
+ if (SvIOK(obj)) {
|
|
3110 |
+ if (val) *val = SvIV(obj); |
|
3111 |
+ return SWIG_OK; |
|
3112 |
+ } else {
|
|
3113 |
+ int dispatch = 0; |
|
3114 |
+ const char *nptr = SvPV_nolen(obj); |
|
3115 |
+ if (nptr) {
|
|
3116 |
+ char *endptr; |
|
3117 |
+ long v; |
|
3118 |
+ errno = 0; |
|
3119 |
+ v = strtol(nptr, &endptr,0); |
|
3120 |
+ if (errno == ERANGE) {
|
|
3121 |
+ errno = 0; |
|
3122 |
+ return SWIG_OverflowError; |
|
3123 |
+ } else {
|
|
3124 |
+ if (*endptr == '\0') {
|
|
3125 |
+ if (val) *val = v; |
|
3126 |
+ return SWIG_Str2NumCast(SWIG_OK); |
|
3127 |
+ } |
|
3128 |
+ } |
|
3129 |
+ } |
|
3130 |
+ if (!dispatch) {
|
|
3131 |
+ double d; |
|
3132 |
+ int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d)); |
|
3133 |
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
|
|
3134 |
+ if (val) *val = (long)(d); |
|
3135 |
+ return res; |
|
3136 |
+ } |
|
3137 |
+ } |
|
3138 |
+ } |
|
3139 |
+ return SWIG_TypeError; |
|
3140 |
+} |
|
3141 |
+ |
|
3142 |
+ |
|
3143 |
+SWIGINTERN int |
|
3144 |
+SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val) |
|
3145 |
+{
|
|
3146 |
+ long v; |
|
3147 |
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v); |
|
3148 |
+ if (SWIG_IsOK(res)) {
|
|
3149 |
+ if ((v < INT_MIN || v > INT_MAX)) {
|
|
3150 |
+ return SWIG_OverflowError; |
|
3151 |
+ } else {
|
|
3152 |
+ if (val) *val = (int)(v); |
|
3153 |
+ } |
|
3154 |
+ } |
|
3155 |
+ return res; |
|
3156 |
+} |
|
3157 |
+ |
|
3158 |
+ |
|
3159 |
+SWIGINTERNINLINE SV * |
|
3160 |
+SWIG_From_char SWIG_PERL_DECL_ARGS_1(char c) |
|
3161 |
+{
|
|
3162 |
+ return SWIG_FromCharPtrAndSize(&c,1); |
|
3163 |
+} |
|
3164 |
+ |
|
3165 |
+#ifdef __cplusplus |
|
3166 |
+extern "C" {
|
|
3167 |
+#endif |
|
3168 |
+ |
|
3169 |
+#ifdef PERL_OBJECT |
|
3170 |
+#define MAGIC_CLASS _wrap_secdb_var:: |
|
3171 |
+class _wrap_secdb_var : public CPerlObj {
|
|
3172 |
+public: |
|
3173 |
+#else |
|
3174 |
+#define MAGIC_CLASS |
|
3175 |
+#endif |
|
3176 |
+SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
|
|
3177 |
+ MAGIC_PPERL |
|
3178 |
+ croak("Value is read-only.");
|
|
3179 |
+ return 0; |
|
3180 |
+} |
|
3181 |
+ |
|
3182 |
+ |
|
3183 |
+#ifdef PERL_OBJECT |
|
3184 |
+}; |
|
3185 |
+#endif |
|
3186 |
+ |
|
3187 |
+#ifdef __cplusplus |
|
3188 |
+} |
|
3189 |
+#endif |
|
3190 |
+ |
|
3191 |
+#ifdef __cplusplus |
|
3192 |
+extern "C" {
|
|
3193 |
+#endif |
|
3194 |
+XS(_wrap_profstr_t_name_set) {
|
|
3195 |
+ {
|
|
3196 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3197 |
+ char *arg2 = (char *) 0 ; |
|
3198 |
+ void *argp1 = 0 ; |
|
3199 |
+ int res1 = 0 ; |
|
3200 |
+ int res2 ; |
|
3201 |
+ char *buf2 = 0 ; |
|
3202 |
+ int alloc2 = 0 ; |
|
3203 |
+ int argvi = 0; |
|
3204 |
+ dXSARGS; |
|
3205 |
+ |
|
3206 |
+ if ((items < 2) || (items > 2)) {
|
|
3207 |
+ SWIG_croak("Usage: profstr_t_name_set(self,name);");
|
|
3208 |
+ } |
|
3209 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3210 |
+ if (!SWIG_IsOK(res1)) {
|
|
3211 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_name_set" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3212 |
+ } |
|
3213 |
+ arg1 = (profstr_t *)(argp1); |
|
3214 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3215 |
+ if (!SWIG_IsOK(res2)) {
|
|
3216 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profstr_t_name_set" "', argument " "2"" of type '" "char *""'"); |
|
3217 |
+ } |
|
3218 |
+ arg2 = (char *)(buf2); |
|
3219 |
+ if (arg1->name) free((char*)arg1->name); |
|
3220 |
+ if (arg2) {
|
|
3221 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3222 |
+ arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3223 |
+ } else {
|
|
3224 |
+ arg1->name = 0; |
|
3225 |
+ } |
|
3226 |
+ |
|
3227 |
+ |
|
3228 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3229 |
+ XSRETURN(argvi); |
|
3230 |
+ fail: |
|
3231 |
+ |
|
3232 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3233 |
+ SWIG_croak_null(); |
|
3234 |
+ } |
|
3235 |
+} |
|
3236 |
+ |
|
3237 |
+ |
|
3238 |
+XS(_wrap_profstr_t_name_get) {
|
|
3239 |
+ {
|
|
3240 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3241 |
+ char *result = 0 ; |
|
3242 |
+ void *argp1 = 0 ; |
|
3243 |
+ int res1 = 0 ; |
|
3244 |
+ int argvi = 0; |
|
3245 |
+ dXSARGS; |
|
3246 |
+ |
|
3247 |
+ if ((items < 1) || (items > 1)) {
|
|
3248 |
+ SWIG_croak("Usage: profstr_t_name_get(self);");
|
|
3249 |
+ } |
|
3250 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3251 |
+ if (!SWIG_IsOK(res1)) {
|
|
3252 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_name_get" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3253 |
+ } |
|
3254 |
+ arg1 = (profstr_t *)(argp1); |
|
3255 |
+ result = (char *) ((arg1)->name); |
|
3256 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3257 |
+ |
|
3258 |
+ XSRETURN(argvi); |
|
3259 |
+ fail: |
|
3260 |
+ |
|
3261 |
+ SWIG_croak_null(); |
|
3262 |
+ } |
|
3263 |
+} |
|
3264 |
+ |
|
3265 |
+ |
|
3266 |
+XS(_wrap_profstr_t_res1_set) {
|
|
3267 |
+ {
|
|
3268 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3269 |
+ char *arg2 = (char *) 0 ; |
|
3270 |
+ void *argp1 = 0 ; |
|
3271 |
+ int res1 = 0 ; |
|
3272 |
+ int res2 ; |
|
3273 |
+ char *buf2 = 0 ; |
|
3274 |
+ int alloc2 = 0 ; |
|
3275 |
+ int argvi = 0; |
|
3276 |
+ dXSARGS; |
|
3277 |
+ |
|
3278 |
+ if ((items < 2) || (items > 2)) {
|
|
3279 |
+ SWIG_croak("Usage: profstr_t_res1_set(self,res1);");
|
|
3280 |
+ } |
|
3281 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3282 |
+ if (!SWIG_IsOK(res1)) {
|
|
3283 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_res1_set" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3284 |
+ } |
|
3285 |
+ arg1 = (profstr_t *)(argp1); |
|
3286 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3287 |
+ if (!SWIG_IsOK(res2)) {
|
|
3288 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profstr_t_res1_set" "', argument " "2"" of type '" "char *""'"); |
|
3289 |
+ } |
|
3290 |
+ arg2 = (char *)(buf2); |
|
3291 |
+ if (arg1->res1) free((char*)arg1->res1); |
|
3292 |
+ if (arg2) {
|
|
3293 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3294 |
+ arg1->res1 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3295 |
+ } else {
|
|
3296 |
+ arg1->res1 = 0; |
|
3297 |
+ } |
|
3298 |
+ |
|
3299 |
+ |
|
3300 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3301 |
+ XSRETURN(argvi); |
|
3302 |
+ fail: |
|
3303 |
+ |
|
3304 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3305 |
+ SWIG_croak_null(); |
|
3306 |
+ } |
|
3307 |
+} |
|
3308 |
+ |
|
3309 |
+ |
|
3310 |
+XS(_wrap_profstr_t_res1_get) {
|
|
3311 |
+ {
|
|
3312 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3313 |
+ char *result = 0 ; |
|
3314 |
+ void *argp1 = 0 ; |
|
3315 |
+ int res1 = 0 ; |
|
3316 |
+ int argvi = 0; |
|
3317 |
+ dXSARGS; |
|
3318 |
+ |
|
3319 |
+ if ((items < 1) || (items > 1)) {
|
|
3320 |
+ SWIG_croak("Usage: profstr_t_res1_get(self);");
|
|
3321 |
+ } |
|
3322 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3323 |
+ if (!SWIG_IsOK(res1)) {
|
|
3324 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_res1_get" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3325 |
+ } |
|
3326 |
+ arg1 = (profstr_t *)(argp1); |
|
3327 |
+ result = (char *) ((arg1)->res1); |
|
3328 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3329 |
+ |
|
3330 |
+ XSRETURN(argvi); |
|
3331 |
+ fail: |
|
3332 |
+ |
|
3333 |
+ SWIG_croak_null(); |
|
3334 |
+ } |
|
3335 |
+} |
|
3336 |
+ |
|
3337 |
+ |
|
3338 |
+XS(_wrap_profstr_t_res2_set) {
|
|
3339 |
+ {
|
|
3340 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3341 |
+ char *arg2 = (char *) 0 ; |
|
3342 |
+ void *argp1 = 0 ; |
|
3343 |
+ int res1 = 0 ; |
|
3344 |
+ int res2 ; |
|
3345 |
+ char *buf2 = 0 ; |
|
3346 |
+ int alloc2 = 0 ; |
|
3347 |
+ int argvi = 0; |
|
3348 |
+ dXSARGS; |
|
3349 |
+ |
|
3350 |
+ if ((items < 2) || (items > 2)) {
|
|
3351 |
+ SWIG_croak("Usage: profstr_t_res2_set(self,res2);");
|
|
3352 |
+ } |
|
3353 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3354 |
+ if (!SWIG_IsOK(res1)) {
|
|
3355 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_res2_set" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3356 |
+ } |
|
3357 |
+ arg1 = (profstr_t *)(argp1); |
|
3358 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3359 |
+ if (!SWIG_IsOK(res2)) {
|
|
3360 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profstr_t_res2_set" "', argument " "2"" of type '" "char *""'"); |
|
3361 |
+ } |
|
3362 |
+ arg2 = (char *)(buf2); |
|
3363 |
+ if (arg1->res2) free((char*)arg1->res2); |
|
3364 |
+ if (arg2) {
|
|
3365 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3366 |
+ arg1->res2 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3367 |
+ } else {
|
|
3368 |
+ arg1->res2 = 0; |
|
3369 |
+ } |
|
3370 |
+ |
|
3371 |
+ |
|
3372 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3373 |
+ XSRETURN(argvi); |
|
3374 |
+ fail: |
|
3375 |
+ |
|
3376 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3377 |
+ SWIG_croak_null(); |
|
3378 |
+ } |
|
3379 |
+} |
|
3380 |
+ |
|
3381 |
+ |
|
3382 |
+XS(_wrap_profstr_t_res2_get) {
|
|
3383 |
+ {
|
|
3384 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3385 |
+ char *result = 0 ; |
|
3386 |
+ void *argp1 = 0 ; |
|
3387 |
+ int res1 = 0 ; |
|
3388 |
+ int argvi = 0; |
|
3389 |
+ dXSARGS; |
|
3390 |
+ |
|
3391 |
+ if ((items < 1) || (items > 1)) {
|
|
3392 |
+ SWIG_croak("Usage: profstr_t_res2_get(self);");
|
|
3393 |
+ } |
|
3394 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3395 |
+ if (!SWIG_IsOK(res1)) {
|
|
3396 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_res2_get" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3397 |
+ } |
|
3398 |
+ arg1 = (profstr_t *)(argp1); |
|
3399 |
+ result = (char *) ((arg1)->res2); |
|
3400 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3401 |
+ |
|
3402 |
+ XSRETURN(argvi); |
|
3403 |
+ fail: |
|
3404 |
+ |
|
3405 |
+ SWIG_croak_null(); |
|
3406 |
+ } |
|
3407 |
+} |
|
3408 |
+ |
|
3409 |
+ |
|
3410 |
+XS(_wrap_profstr_t_desc_set) {
|
|
3411 |
+ {
|
|
3412 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3413 |
+ char *arg2 = (char *) 0 ; |
|
3414 |
+ void *argp1 = 0 ; |
|
3415 |
+ int res1 = 0 ; |
|
3416 |
+ int res2 ; |
|
3417 |
+ char *buf2 = 0 ; |
|
3418 |
+ int alloc2 = 0 ; |
|
3419 |
+ int argvi = 0; |
|
3420 |
+ dXSARGS; |
|
3421 |
+ |
|
3422 |
+ if ((items < 2) || (items > 2)) {
|
|
3423 |
+ SWIG_croak("Usage: profstr_t_desc_set(self,desc);");
|
|
3424 |
+ } |
|
3425 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3426 |
+ if (!SWIG_IsOK(res1)) {
|
|
3427 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_desc_set" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3428 |
+ } |
|
3429 |
+ arg1 = (profstr_t *)(argp1); |
|
3430 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3431 |
+ if (!SWIG_IsOK(res2)) {
|
|
3432 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profstr_t_desc_set" "', argument " "2"" of type '" "char *""'"); |
|
3433 |
+ } |
|
3434 |
+ arg2 = (char *)(buf2); |
|
3435 |
+ if (arg1->desc) free((char*)arg1->desc); |
|
3436 |
+ if (arg2) {
|
|
3437 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3438 |
+ arg1->desc = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3439 |
+ } else {
|
|
3440 |
+ arg1->desc = 0; |
|
3441 |
+ } |
|
3442 |
+ |
|
3443 |
+ |
|
3444 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3445 |
+ XSRETURN(argvi); |
|
3446 |
+ fail: |
|
3447 |
+ |
|
3448 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3449 |
+ SWIG_croak_null(); |
|
3450 |
+ } |
|
3451 |
+} |
|
3452 |
+ |
|
3453 |
+ |
|
3454 |
+XS(_wrap_profstr_t_desc_get) {
|
|
3455 |
+ {
|
|
3456 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3457 |
+ char *result = 0 ; |
|
3458 |
+ void *argp1 = 0 ; |
|
3459 |
+ int res1 = 0 ; |
|
3460 |
+ int argvi = 0; |
|
3461 |
+ dXSARGS; |
|
3462 |
+ |
|
3463 |
+ if ((items < 1) || (items > 1)) {
|
|
3464 |
+ SWIG_croak("Usage: profstr_t_desc_get(self);");
|
|
3465 |
+ } |
|
3466 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3467 |
+ if (!SWIG_IsOK(res1)) {
|
|
3468 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_desc_get" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3469 |
+ } |
|
3470 |
+ arg1 = (profstr_t *)(argp1); |
|
3471 |
+ result = (char *) ((arg1)->desc); |
|
3472 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3473 |
+ |
|
3474 |
+ XSRETURN(argvi); |
|
3475 |
+ fail: |
|
3476 |
+ |
|
3477 |
+ SWIG_croak_null(); |
|
3478 |
+ } |
|
3479 |
+} |
|
3480 |
+ |
|
3481 |
+ |
|
3482 |
+XS(_wrap_profstr_t_attr_set) {
|
|
3483 |
+ {
|
|
3484 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3485 |
+ char *arg2 = (char *) 0 ; |
|
3486 |
+ void *argp1 = 0 ; |
|
3487 |
+ int res1 = 0 ; |
|
3488 |
+ int res2 ; |
|
3489 |
+ char *buf2 = 0 ; |
|
3490 |
+ int alloc2 = 0 ; |
|
3491 |
+ int argvi = 0; |
|
3492 |
+ dXSARGS; |
|
3493 |
+ |
|
3494 |
+ if ((items < 2) || (items > 2)) {
|
|
3495 |
+ SWIG_croak("Usage: profstr_t_attr_set(self,attr);");
|
|
3496 |
+ } |
|
3497 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3498 |
+ if (!SWIG_IsOK(res1)) {
|
|
3499 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_attr_set" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3500 |
+ } |
|
3501 |
+ arg1 = (profstr_t *)(argp1); |
|
3502 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3503 |
+ if (!SWIG_IsOK(res2)) {
|
|
3504 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profstr_t_attr_set" "', argument " "2"" of type '" "char *""'"); |
|
3505 |
+ } |
|
3506 |
+ arg2 = (char *)(buf2); |
|
3507 |
+ if (arg1->attr) free((char*)arg1->attr); |
|
3508 |
+ if (arg2) {
|
|
3509 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3510 |
+ arg1->attr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3511 |
+ } else {
|
|
3512 |
+ arg1->attr = 0; |
|
3513 |
+ } |
|
3514 |
+ |
|
3515 |
+ |
|
3516 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3517 |
+ XSRETURN(argvi); |
|
3518 |
+ fail: |
|
3519 |
+ |
|
3520 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3521 |
+ SWIG_croak_null(); |
|
3522 |
+ } |
|
3523 |
+} |
|
3524 |
+ |
|
3525 |
+ |
|
3526 |
+XS(_wrap_profstr_t_attr_get) {
|
|
3527 |
+ {
|
|
3528 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3529 |
+ char *result = 0 ; |
|
3530 |
+ void *argp1 = 0 ; |
|
3531 |
+ int res1 = 0 ; |
|
3532 |
+ int argvi = 0; |
|
3533 |
+ dXSARGS; |
|
3534 |
+ |
|
3535 |
+ if ((items < 1) || (items > 1)) {
|
|
3536 |
+ SWIG_croak("Usage: profstr_t_attr_get(self);");
|
|
3537 |
+ } |
|
3538 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, 0 | 0 ); |
|
3539 |
+ if (!SWIG_IsOK(res1)) {
|
|
3540 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profstr_t_attr_get" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3541 |
+ } |
|
3542 |
+ arg1 = (profstr_t *)(argp1); |
|
3543 |
+ result = (char *) ((arg1)->attr); |
|
3544 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3545 |
+ |
|
3546 |
+ XSRETURN(argvi); |
|
3547 |
+ fail: |
|
3548 |
+ |
|
3549 |
+ SWIG_croak_null(); |
|
3550 |
+ } |
|
3551 |
+} |
|
3552 |
+ |
|
3553 |
+ |
|
3554 |
+XS(_wrap_new_profstr_t) {
|
|
3555 |
+ {
|
|
3556 |
+ profstr_t *result = 0 ; |
|
3557 |
+ int argvi = 0; |
|
3558 |
+ dXSARGS; |
|
3559 |
+ |
|
3560 |
+ if ((items < 0) || (items > 0)) {
|
|
3561 |
+ SWIG_croak("Usage: new_profstr_t();");
|
|
3562 |
+ } |
|
3563 |
+ result = (profstr_t *)calloc(1, sizeof(profstr_t)); |
|
3564 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_profstr_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
3565 |
+ XSRETURN(argvi); |
|
3566 |
+ fail: |
|
3567 |
+ SWIG_croak_null(); |
|
3568 |
+ } |
|
3569 |
+} |
|
3570 |
+ |
|
3571 |
+ |
|
3572 |
+XS(_wrap_delete_profstr_t) {
|
|
3573 |
+ {
|
|
3574 |
+ profstr_t *arg1 = (profstr_t *) 0 ; |
|
3575 |
+ void *argp1 = 0 ; |
|
3576 |
+ int res1 = 0 ; |
|
3577 |
+ int argvi = 0; |
|
3578 |
+ dXSARGS; |
|
3579 |
+ |
|
3580 |
+ if ((items < 1) || (items > 1)) {
|
|
3581 |
+ SWIG_croak("Usage: delete_profstr_t(self);");
|
|
3582 |
+ } |
|
3583 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profstr_s, SWIG_POINTER_DISOWN | 0 ); |
|
3584 |
+ if (!SWIG_IsOK(res1)) {
|
|
3585 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_profstr_t" "', argument " "1"" of type '" "profstr_t *""'"); |
|
3586 |
+ } |
|
3587 |
+ arg1 = (profstr_t *)(argp1); |
|
3588 |
+ free((char *) arg1); |
|
3589 |
+ |
|
3590 |
+ |
|
3591 |
+ |
|
3592 |
+ XSRETURN(argvi); |
|
3593 |
+ fail: |
|
3594 |
+ |
|
3595 |
+ SWIG_croak_null(); |
|
3596 |
+ } |
|
3597 |
+} |
|
3598 |
+ |
|
3599 |
+ |
|
3600 |
+XS(_wrap_profattr_t_name_set) {
|
|
3601 |
+ {
|
|
3602 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3603 |
+ char *arg2 = (char *) 0 ; |
|
3604 |
+ void *argp1 = 0 ; |
|
3605 |
+ int res1 = 0 ; |
|
3606 |
+ int res2 ; |
|
3607 |
+ char *buf2 = 0 ; |
|
3608 |
+ int alloc2 = 0 ; |
|
3609 |
+ int argvi = 0; |
|
3610 |
+ dXSARGS; |
|
3611 |
+ |
|
3612 |
+ if ((items < 2) || (items > 2)) {
|
|
3613 |
+ SWIG_croak("Usage: profattr_t_name_set(self,name);");
|
|
3614 |
+ } |
|
3615 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3616 |
+ if (!SWIG_IsOK(res1)) {
|
|
3617 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_name_set" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3618 |
+ } |
|
3619 |
+ arg1 = (profattr_t *)(argp1); |
|
3620 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3621 |
+ if (!SWIG_IsOK(res2)) {
|
|
3622 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profattr_t_name_set" "', argument " "2"" of type '" "char *""'"); |
|
3623 |
+ } |
|
3624 |
+ arg2 = (char *)(buf2); |
|
3625 |
+ if (arg1->name) free((char*)arg1->name); |
|
3626 |
+ if (arg2) {
|
|
3627 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3628 |
+ arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3629 |
+ } else {
|
|
3630 |
+ arg1->name = 0; |
|
3631 |
+ } |
|
3632 |
+ |
|
3633 |
+ |
|
3634 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3635 |
+ XSRETURN(argvi); |
|
3636 |
+ fail: |
|
3637 |
+ |
|
3638 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3639 |
+ SWIG_croak_null(); |
|
3640 |
+ } |
|
3641 |
+} |
|
3642 |
+ |
|
3643 |
+ |
|
3644 |
+XS(_wrap_profattr_t_name_get) {
|
|
3645 |
+ {
|
|
3646 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3647 |
+ char *result = 0 ; |
|
3648 |
+ void *argp1 = 0 ; |
|
3649 |
+ int res1 = 0 ; |
|
3650 |
+ int argvi = 0; |
|
3651 |
+ dXSARGS; |
|
3652 |
+ |
|
3653 |
+ if ((items < 1) || (items > 1)) {
|
|
3654 |
+ SWIG_croak("Usage: profattr_t_name_get(self);");
|
|
3655 |
+ } |
|
3656 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3657 |
+ if (!SWIG_IsOK(res1)) {
|
|
3658 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_name_get" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3659 |
+ } |
|
3660 |
+ arg1 = (profattr_t *)(argp1); |
|
3661 |
+ result = (char *) ((arg1)->name); |
|
3662 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3663 |
+ |
|
3664 |
+ XSRETURN(argvi); |
|
3665 |
+ fail: |
|
3666 |
+ |
|
3667 |
+ SWIG_croak_null(); |
|
3668 |
+ } |
|
3669 |
+} |
|
3670 |
+ |
|
3671 |
+ |
|
3672 |
+XS(_wrap_profattr_t_res1_set) {
|
|
3673 |
+ {
|
|
3674 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3675 |
+ char *arg2 = (char *) 0 ; |
|
3676 |
+ void *argp1 = 0 ; |
|
3677 |
+ int res1 = 0 ; |
|
3678 |
+ int res2 ; |
|
3679 |
+ char *buf2 = 0 ; |
|
3680 |
+ int alloc2 = 0 ; |
|
3681 |
+ int argvi = 0; |
|
3682 |
+ dXSARGS; |
|
3683 |
+ |
|
3684 |
+ if ((items < 2) || (items > 2)) {
|
|
3685 |
+ SWIG_croak("Usage: profattr_t_res1_set(self,res1);");
|
|
3686 |
+ } |
|
3687 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3688 |
+ if (!SWIG_IsOK(res1)) {
|
|
3689 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_res1_set" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3690 |
+ } |
|
3691 |
+ arg1 = (profattr_t *)(argp1); |
|
3692 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3693 |
+ if (!SWIG_IsOK(res2)) {
|
|
3694 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profattr_t_res1_set" "', argument " "2"" of type '" "char *""'"); |
|
3695 |
+ } |
|
3696 |
+ arg2 = (char *)(buf2); |
|
3697 |
+ if (arg1->res1) free((char*)arg1->res1); |
|
3698 |
+ if (arg2) {
|
|
3699 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3700 |
+ arg1->res1 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3701 |
+ } else {
|
|
3702 |
+ arg1->res1 = 0; |
|
3703 |
+ } |
|
3704 |
+ |
|
3705 |
+ |
|
3706 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3707 |
+ XSRETURN(argvi); |
|
3708 |
+ fail: |
|
3709 |
+ |
|
3710 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3711 |
+ SWIG_croak_null(); |
|
3712 |
+ } |
|
3713 |
+} |
|
3714 |
+ |
|
3715 |
+ |
|
3716 |
+XS(_wrap_profattr_t_res1_get) {
|
|
3717 |
+ {
|
|
3718 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3719 |
+ char *result = 0 ; |
|
3720 |
+ void *argp1 = 0 ; |
|
3721 |
+ int res1 = 0 ; |
|
3722 |
+ int argvi = 0; |
|
3723 |
+ dXSARGS; |
|
3724 |
+ |
|
3725 |
+ if ((items < 1) || (items > 1)) {
|
|
3726 |
+ SWIG_croak("Usage: profattr_t_res1_get(self);");
|
|
3727 |
+ } |
|
3728 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3729 |
+ if (!SWIG_IsOK(res1)) {
|
|
3730 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_res1_get" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3731 |
+ } |
|
3732 |
+ arg1 = (profattr_t *)(argp1); |
|
3733 |
+ result = (char *) ((arg1)->res1); |
|
3734 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3735 |
+ |
|
3736 |
+ XSRETURN(argvi); |
|
3737 |
+ fail: |
|
3738 |
+ |
|
3739 |
+ SWIG_croak_null(); |
|
3740 |
+ } |
|
3741 |
+} |
|
3742 |
+ |
|
3743 |
+ |
|
3744 |
+XS(_wrap_profattr_t_res2_set) {
|
|
3745 |
+ {
|
|
3746 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3747 |
+ char *arg2 = (char *) 0 ; |
|
3748 |
+ void *argp1 = 0 ; |
|
3749 |
+ int res1 = 0 ; |
|
3750 |
+ int res2 ; |
|
3751 |
+ char *buf2 = 0 ; |
|
3752 |
+ int alloc2 = 0 ; |
|
3753 |
+ int argvi = 0; |
|
3754 |
+ dXSARGS; |
|
3755 |
+ |
|
3756 |
+ if ((items < 2) || (items > 2)) {
|
|
3757 |
+ SWIG_croak("Usage: profattr_t_res2_set(self,res2);");
|
|
3758 |
+ } |
|
3759 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3760 |
+ if (!SWIG_IsOK(res1)) {
|
|
3761 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_res2_set" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3762 |
+ } |
|
3763 |
+ arg1 = (profattr_t *)(argp1); |
|
3764 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3765 |
+ if (!SWIG_IsOK(res2)) {
|
|
3766 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profattr_t_res2_set" "', argument " "2"" of type '" "char *""'"); |
|
3767 |
+ } |
|
3768 |
+ arg2 = (char *)(buf2); |
|
3769 |
+ if (arg1->res2) free((char*)arg1->res2); |
|
3770 |
+ if (arg2) {
|
|
3771 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3772 |
+ arg1->res2 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3773 |
+ } else {
|
|
3774 |
+ arg1->res2 = 0; |
|
3775 |
+ } |
|
3776 |
+ |
|
3777 |
+ |
|
3778 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3779 |
+ XSRETURN(argvi); |
|
3780 |
+ fail: |
|
3781 |
+ |
|
3782 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3783 |
+ SWIG_croak_null(); |
|
3784 |
+ } |
|
3785 |
+} |
|
3786 |
+ |
|
3787 |
+ |
|
3788 |
+XS(_wrap_profattr_t_res2_get) {
|
|
3789 |
+ {
|
|
3790 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3791 |
+ char *result = 0 ; |
|
3792 |
+ void *argp1 = 0 ; |
|
3793 |
+ int res1 = 0 ; |
|
3794 |
+ int argvi = 0; |
|
3795 |
+ dXSARGS; |
|
3796 |
+ |
|
3797 |
+ if ((items < 1) || (items > 1)) {
|
|
3798 |
+ SWIG_croak("Usage: profattr_t_res2_get(self);");
|
|
3799 |
+ } |
|
3800 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3801 |
+ if (!SWIG_IsOK(res1)) {
|
|
3802 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_res2_get" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3803 |
+ } |
|
3804 |
+ arg1 = (profattr_t *)(argp1); |
|
3805 |
+ result = (char *) ((arg1)->res2); |
|
3806 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3807 |
+ |
|
3808 |
+ XSRETURN(argvi); |
|
3809 |
+ fail: |
|
3810 |
+ |
|
3811 |
+ SWIG_croak_null(); |
|
3812 |
+ } |
|
3813 |
+} |
|
3814 |
+ |
|
3815 |
+ |
|
3816 |
+XS(_wrap_profattr_t_desc_set) {
|
|
3817 |
+ {
|
|
3818 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3819 |
+ char *arg2 = (char *) 0 ; |
|
3820 |
+ void *argp1 = 0 ; |
|
3821 |
+ int res1 = 0 ; |
|
3822 |
+ int res2 ; |
|
3823 |
+ char *buf2 = 0 ; |
|
3824 |
+ int alloc2 = 0 ; |
|
3825 |
+ int argvi = 0; |
|
3826 |
+ dXSARGS; |
|
3827 |
+ |
|
3828 |
+ if ((items < 2) || (items > 2)) {
|
|
3829 |
+ SWIG_croak("Usage: profattr_t_desc_set(self,desc);");
|
|
3830 |
+ } |
|
3831 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3832 |
+ if (!SWIG_IsOK(res1)) {
|
|
3833 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_desc_set" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3834 |
+ } |
|
3835 |
+ arg1 = (profattr_t *)(argp1); |
|
3836 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
3837 |
+ if (!SWIG_IsOK(res2)) {
|
|
3838 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profattr_t_desc_set" "', argument " "2"" of type '" "char *""'"); |
|
3839 |
+ } |
|
3840 |
+ arg2 = (char *)(buf2); |
|
3841 |
+ if (arg1->desc) free((char*)arg1->desc); |
|
3842 |
+ if (arg2) {
|
|
3843 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
3844 |
+ arg1->desc = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
3845 |
+ } else {
|
|
3846 |
+ arg1->desc = 0; |
|
3847 |
+ } |
|
3848 |
+ |
|
3849 |
+ |
|
3850 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3851 |
+ XSRETURN(argvi); |
|
3852 |
+ fail: |
|
3853 |
+ |
|
3854 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
3855 |
+ SWIG_croak_null(); |
|
3856 |
+ } |
|
3857 |
+} |
|
3858 |
+ |
|
3859 |
+ |
|
3860 |
+XS(_wrap_profattr_t_desc_get) {
|
|
3861 |
+ {
|
|
3862 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3863 |
+ char *result = 0 ; |
|
3864 |
+ void *argp1 = 0 ; |
|
3865 |
+ int res1 = 0 ; |
|
3866 |
+ int argvi = 0; |
|
3867 |
+ dXSARGS; |
|
3868 |
+ |
|
3869 |
+ if ((items < 1) || (items > 1)) {
|
|
3870 |
+ SWIG_croak("Usage: profattr_t_desc_get(self);");
|
|
3871 |
+ } |
|
3872 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3873 |
+ if (!SWIG_IsOK(res1)) {
|
|
3874 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_desc_get" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3875 |
+ } |
|
3876 |
+ arg1 = (profattr_t *)(argp1); |
|
3877 |
+ result = (char *) ((arg1)->desc); |
|
3878 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
3879 |
+ |
|
3880 |
+ XSRETURN(argvi); |
|
3881 |
+ fail: |
|
3882 |
+ |
|
3883 |
+ SWIG_croak_null(); |
|
3884 |
+ } |
|
3885 |
+} |
|
3886 |
+ |
|
3887 |
+ |
|
3888 |
+XS(_wrap_profattr_t_attr_set) {
|
|
3889 |
+ {
|
|
3890 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3891 |
+ kva_t *arg2 = (kva_t *) 0 ; |
|
3892 |
+ void *argp1 = 0 ; |
|
3893 |
+ int res1 = 0 ; |
|
3894 |
+ void *argp2 = 0 ; |
|
3895 |
+ int res2 = 0 ; |
|
3896 |
+ int argvi = 0; |
|
3897 |
+ dXSARGS; |
|
3898 |
+ |
|
3899 |
+ if ((items < 2) || (items > 2)) {
|
|
3900 |
+ SWIG_croak("Usage: profattr_t_attr_set(self,attr);");
|
|
3901 |
+ } |
|
3902 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3903 |
+ if (!SWIG_IsOK(res1)) {
|
|
3904 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_attr_set" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3905 |
+ } |
|
3906 |
+ arg1 = (profattr_t *)(argp1); |
|
3907 |
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_kva_s, SWIG_POINTER_DISOWN | 0 ); |
|
3908 |
+ if (!SWIG_IsOK(res2)) {
|
|
3909 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profattr_t_attr_set" "', argument " "2"" of type '" "kva_t *""'"); |
|
3910 |
+ } |
|
3911 |
+ arg2 = (kva_t *)(argp2); |
|
3912 |
+ if (arg1) (arg1)->attr = arg2; |
|
3913 |
+ |
|
3914 |
+ |
|
3915 |
+ |
|
3916 |
+ |
|
3917 |
+ XSRETURN(argvi); |
|
3918 |
+ fail: |
|
3919 |
+ |
|
3920 |
+ |
|
3921 |
+ SWIG_croak_null(); |
|
3922 |
+ } |
|
3923 |
+} |
|
3924 |
+ |
|
3925 |
+ |
|
3926 |
+XS(_wrap_profattr_t_attr_get) {
|
|
3927 |
+ {
|
|
3928 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3929 |
+ kva_t *result = 0 ; |
|
3930 |
+ void *argp1 = 0 ; |
|
3931 |
+ int res1 = 0 ; |
|
3932 |
+ int argvi = 0; |
|
3933 |
+ dXSARGS; |
|
3934 |
+ |
|
3935 |
+ if ((items < 1) || (items > 1)) {
|
|
3936 |
+ SWIG_croak("Usage: profattr_t_attr_get(self);");
|
|
3937 |
+ } |
|
3938 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
3939 |
+ if (!SWIG_IsOK(res1)) {
|
|
3940 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profattr_t_attr_get" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3941 |
+ } |
|
3942 |
+ arg1 = (profattr_t *)(argp1); |
|
3943 |
+ result = (kva_t *) ((arg1)->attr); |
|
3944 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, 0 | SWIG_SHADOW); argvi++ ; |
|
3945 |
+ |
|
3946 |
+ XSRETURN(argvi); |
|
3947 |
+ fail: |
|
3948 |
+ |
|
3949 |
+ SWIG_croak_null(); |
|
3950 |
+ } |
|
3951 |
+} |
|
3952 |
+ |
|
3953 |
+ |
|
3954 |
+XS(_wrap_new_profattr_t) {
|
|
3955 |
+ {
|
|
3956 |
+ profattr_t *result = 0 ; |
|
3957 |
+ int argvi = 0; |
|
3958 |
+ dXSARGS; |
|
3959 |
+ |
|
3960 |
+ if ((items < 0) || (items > 0)) {
|
|
3961 |
+ SWIG_croak("Usage: new_profattr_t();");
|
|
3962 |
+ } |
|
3963 |
+ result = (profattr_t *)calloc(1, sizeof(profattr_t)); |
|
3964 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_profattr_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
3965 |
+ XSRETURN(argvi); |
|
3966 |
+ fail: |
|
3967 |
+ SWIG_croak_null(); |
|
3968 |
+ } |
|
3969 |
+} |
|
3970 |
+ |
|
3971 |
+ |
|
3972 |
+XS(_wrap_delete_profattr_t) {
|
|
3973 |
+ {
|
|
3974 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
3975 |
+ void *argp1 = 0 ; |
|
3976 |
+ int res1 = 0 ; |
|
3977 |
+ int argvi = 0; |
|
3978 |
+ dXSARGS; |
|
3979 |
+ |
|
3980 |
+ if ((items < 1) || (items > 1)) {
|
|
3981 |
+ SWIG_croak("Usage: delete_profattr_t(self);");
|
|
3982 |
+ } |
|
3983 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, SWIG_POINTER_DISOWN | 0 ); |
|
3984 |
+ if (!SWIG_IsOK(res1)) {
|
|
3985 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_profattr_t" "', argument " "1"" of type '" "profattr_t *""'"); |
|
3986 |
+ } |
|
3987 |
+ arg1 = (profattr_t *)(argp1); |
|
3988 |
+ free((char *) arg1); |
|
3989 |
+ |
|
3990 |
+ |
|
3991 |
+ |
|
3992 |
+ XSRETURN(argvi); |
|
3993 |
+ fail: |
|
3994 |
+ |
|
3995 |
+ SWIG_croak_null(); |
|
3996 |
+ } |
|
3997 |
+} |
|
3998 |
+ |
|
3999 |
+ |
|
4000 |
+XS(_wrap_getprofnam) {
|
|
4001 |
+ {
|
|
4002 |
+ char *arg1 = (char *) 0 ; |
|
4003 |
+ profattr_t *result = 0 ; |
|
4004 |
+ int res1 ; |
|
4005 |
+ char *buf1 = 0 ; |
|
4006 |
+ int alloc1 = 0 ; |
|
4007 |
+ int argvi = 0; |
|
4008 |
+ dXSARGS; |
|
4009 |
+ |
|
4010 |
+ if ((items < 1) || (items > 1)) {
|
|
4011 |
+ SWIG_croak("Usage: getprofnam(char const *);");
|
|
4012 |
+ } |
|
4013 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
4014 |
+ if (!SWIG_IsOK(res1)) {
|
|
4015 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getprofnam" "', argument " "1"" of type '" "char const *""'"); |
|
4016 |
+ } |
|
4017 |
+ arg1 = (char *)(buf1); |
|
4018 |
+ result = (profattr_t *)getprofnam((char const *)arg1); |
|
4019 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_profattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
4020 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
4021 |
+ XSRETURN(argvi); |
|
4022 |
+ fail: |
|
4023 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
4024 |
+ SWIG_croak_null(); |
|
4025 |
+ } |
|
4026 |
+} |
|
4027 |
+ |
|
4028 |
+ |
|
4029 |
+XS(_wrap_getprofattr) {
|
|
4030 |
+ {
|
|
4031 |
+ profattr_t *result = 0 ; |
|
4032 |
+ int argvi = 0; |
|
4033 |
+ dXSARGS; |
|
4034 |
+ |
|
4035 |
+ if ((items < 0) || (items > 0)) {
|
|
4036 |
+ SWIG_croak("Usage: getprofattr();");
|
|
4037 |
+ } |
|
4038 |
+ result = (profattr_t *)getprofattr(); |
|
4039 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_profattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
4040 |
+ XSRETURN(argvi); |
|
4041 |
+ fail: |
|
4042 |
+ SWIG_croak_null(); |
|
4043 |
+ } |
|
4044 |
+} |
|
4045 |
+ |
|
4046 |
+ |
|
4047 |
+XS(_wrap_getproflist) {
|
|
4048 |
+ {
|
|
4049 |
+ char *arg1 = (char *) 0 ; |
|
4050 |
+ char **arg2 = (char **) 0 ; |
|
4051 |
+ int *arg3 = (int *) 0 ; |
|
4052 |
+ int res1 ; |
|
4053 |
+ char *buf1 = 0 ; |
|
4054 |
+ int alloc1 = 0 ; |
|
4055 |
+ void *argp2 = 0 ; |
|
4056 |
+ int res2 = 0 ; |
|
4057 |
+ void *argp3 = 0 ; |
|
4058 |
+ int res3 = 0 ; |
|
4059 |
+ int argvi = 0; |
|
4060 |
+ dXSARGS; |
|
4061 |
+ |
|
4062 |
+ if ((items < 3) || (items > 3)) {
|
|
4063 |
+ SWIG_croak("Usage: getproflist(char const *,char **,int *);");
|
|
4064 |
+ } |
|
4065 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
4066 |
+ if (!SWIG_IsOK(res1)) {
|
|
4067 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getproflist" "', argument " "1"" of type '" "char const *""'"); |
|
4068 |
+ } |
|
4069 |
+ arg1 = (char *)(buf1); |
|
4070 |
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 ); |
|
4071 |
+ if (!SWIG_IsOK(res2)) {
|
|
4072 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getproflist" "', argument " "2"" of type '" "char **""'"); |
|
4073 |
+ } |
|
4074 |
+ arg2 = (char **)(argp2); |
|
4075 |
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 | 0 ); |
|
4076 |
+ if (!SWIG_IsOK(res3)) {
|
|
4077 |
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "getproflist" "', argument " "3"" of type '" "int *""'"); |
|
4078 |
+ } |
|
4079 |
+ arg3 = (int *)(argp3); |
|
4080 |
+ getproflist((char const *)arg1,arg2,arg3); |
|
4081 |
+ |
|
4082 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
4083 |
+ |
|
4084 |
+ |
|
4085 |
+ XSRETURN(argvi); |
|
4086 |
+ fail: |
|
4087 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
4088 |
+ |
|
4089 |
+ |
|
4090 |
+ SWIG_croak_null(); |
|
4091 |
+ } |
|
4092 |
+} |
|
4093 |
+ |
|
4094 |
+ |
|
4095 |
+XS(_wrap_setprofattr) {
|
|
4096 |
+ {
|
|
4097 |
+ int argvi = 0; |
|
4098 |
+ dXSARGS; |
|
4099 |
+ |
|
4100 |
+ if ((items < 0) || (items > 0)) {
|
|
4101 |
+ SWIG_croak("Usage: setprofattr();");
|
|
4102 |
+ } |
|
4103 |
+ setprofattr(); |
|
4104 |
+ |
|
4105 |
+ XSRETURN(argvi); |
|
4106 |
+ fail: |
|
4107 |
+ SWIG_croak_null(); |
|
4108 |
+ } |
|
4109 |
+} |
|
4110 |
+ |
|
4111 |
+ |
|
4112 |
+XS(_wrap_endprofattr) {
|
|
4113 |
+ {
|
|
4114 |
+ int argvi = 0; |
|
4115 |
+ dXSARGS; |
|
4116 |
+ |
|
4117 |
+ if ((items < 0) || (items > 0)) {
|
|
4118 |
+ SWIG_croak("Usage: endprofattr();");
|
|
4119 |
+ } |
|
4120 |
+ endprofattr(); |
|
4121 |
+ |
|
4122 |
+ XSRETURN(argvi); |
|
4123 |
+ fail: |
|
4124 |
+ SWIG_croak_null(); |
|
4125 |
+ } |
|
4126 |
+} |
|
4127 |
+ |
|
4128 |
+ |
|
4129 |
+XS(_wrap_free_profattr) {
|
|
4130 |
+ {
|
|
4131 |
+ profattr_t *arg1 = (profattr_t *) 0 ; |
|
4132 |
+ void *argp1 = 0 ; |
|
4133 |
+ int res1 = 0 ; |
|
4134 |
+ int argvi = 0; |
|
4135 |
+ dXSARGS; |
|
4136 |
+ |
|
4137 |
+ if ((items < 1) || (items > 1)) {
|
|
4138 |
+ SWIG_croak("Usage: free_profattr(profattr_t *);");
|
|
4139 |
+ } |
|
4140 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_profattr_s, 0 | 0 ); |
|
4141 |
+ if (!SWIG_IsOK(res1)) {
|
|
4142 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_profattr" "', argument " "1"" of type '" "profattr_t *""'"); |
|
4143 |
+ } |
|
4144 |
+ arg1 = (profattr_t *)(argp1); |
|
4145 |
+ free_profattr(arg1); |
|
4146 |
+ |
|
4147 |
+ |
|
4148 |
+ XSRETURN(argvi); |
|
4149 |
+ fail: |
|
4150 |
+ |
|
4151 |
+ SWIG_croak_null(); |
|
4152 |
+ } |
|
4153 |
+} |
|
4154 |
+ |
|
4155 |
+ |
|
4156 |
+XS(_wrap_free_proflist) {
|
|
4157 |
+ {
|
|
4158 |
+ char **arg1 = (char **) 0 ; |
|
4159 |
+ int arg2 ; |
|
4160 |
+ void *argp1 = 0 ; |
|
4161 |
+ int res1 = 0 ; |
|
4162 |
+ int val2 ; |
|
4163 |
+ int ecode2 = 0 ; |
|
4164 |
+ int argvi = 0; |
|
4165 |
+ dXSARGS; |
|
4166 |
+ |
|
4167 |
+ if ((items < 2) || (items > 2)) {
|
|
4168 |
+ SWIG_croak("Usage: free_proflist(char **,int);");
|
|
4169 |
+ } |
|
4170 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_char, 0 | 0 ); |
|
4171 |
+ if (!SWIG_IsOK(res1)) {
|
|
4172 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_proflist" "', argument " "1"" of type '" "char **""'"); |
|
4173 |
+ } |
|
4174 |
+ arg1 = (char **)(argp1); |
|
4175 |
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2); |
|
4176 |
+ if (!SWIG_IsOK(ecode2)) {
|
|
4177 |
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "free_proflist" "', argument " "2"" of type '" "int""'"); |
|
4178 |
+ } |
|
4179 |
+ arg2 = (int)(val2); |
|
4180 |
+ free_proflist(arg1,arg2); |
|
4181 |
+ |
|
4182 |
+ |
|
4183 |
+ |
|
4184 |
+ XSRETURN(argvi); |
|
4185 |
+ fail: |
|
4186 |
+ |
|
4187 |
+ |
|
4188 |
+ SWIG_croak_null(); |
|
4189 |
+ } |
|
4190 |
+} |
|
4191 |
+ |
|
4192 |
+ |
|
4193 |
+XS(_wrap_userstr_t_name_set) {
|
|
4194 |
+ {
|
|
4195 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4196 |
+ char *arg2 = (char *) 0 ; |
|
4197 |
+ void *argp1 = 0 ; |
|
4198 |
+ int res1 = 0 ; |
|
4199 |
+ int res2 ; |
|
4200 |
+ char *buf2 = 0 ; |
|
4201 |
+ int alloc2 = 0 ; |
|
4202 |
+ int argvi = 0; |
|
4203 |
+ dXSARGS; |
|
4204 |
+ |
|
4205 |
+ if ((items < 2) || (items > 2)) {
|
|
4206 |
+ SWIG_croak("Usage: userstr_t_name_set(self,name);");
|
|
4207 |
+ } |
|
4208 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4209 |
+ if (!SWIG_IsOK(res1)) {
|
|
4210 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_name_set" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4211 |
+ } |
|
4212 |
+ arg1 = (userstr_t *)(argp1); |
|
4213 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4214 |
+ if (!SWIG_IsOK(res2)) {
|
|
4215 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userstr_t_name_set" "', argument " "2"" of type '" "char *""'"); |
|
4216 |
+ } |
|
4217 |
+ arg2 = (char *)(buf2); |
|
4218 |
+ if (arg1->name) free((char*)arg1->name); |
|
4219 |
+ if (arg2) {
|
|
4220 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4221 |
+ arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4222 |
+ } else {
|
|
4223 |
+ arg1->name = 0; |
|
4224 |
+ } |
|
4225 |
+ |
|
4226 |
+ |
|
4227 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4228 |
+ XSRETURN(argvi); |
|
4229 |
+ fail: |
|
4230 |
+ |
|
4231 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4232 |
+ SWIG_croak_null(); |
|
4233 |
+ } |
|
4234 |
+} |
|
4235 |
+ |
|
4236 |
+ |
|
4237 |
+XS(_wrap_userstr_t_name_get) {
|
|
4238 |
+ {
|
|
4239 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4240 |
+ char *result = 0 ; |
|
4241 |
+ void *argp1 = 0 ; |
|
4242 |
+ int res1 = 0 ; |
|
4243 |
+ int argvi = 0; |
|
4244 |
+ dXSARGS; |
|
4245 |
+ |
|
4246 |
+ if ((items < 1) || (items > 1)) {
|
|
4247 |
+ SWIG_croak("Usage: userstr_t_name_get(self);");
|
|
4248 |
+ } |
|
4249 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4250 |
+ if (!SWIG_IsOK(res1)) {
|
|
4251 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_name_get" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4252 |
+ } |
|
4253 |
+ arg1 = (userstr_t *)(argp1); |
|
4254 |
+ result = (char *) ((arg1)->name); |
|
4255 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4256 |
+ |
|
4257 |
+ XSRETURN(argvi); |
|
4258 |
+ fail: |
|
4259 |
+ |
|
4260 |
+ SWIG_croak_null(); |
|
4261 |
+ } |
|
4262 |
+} |
|
4263 |
+ |
|
4264 |
+ |
|
4265 |
+XS(_wrap_userstr_t_qualifier_set) {
|
|
4266 |
+ {
|
|
4267 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4268 |
+ char *arg2 = (char *) 0 ; |
|
4269 |
+ void *argp1 = 0 ; |
|
4270 |
+ int res1 = 0 ; |
|
4271 |
+ int res2 ; |
|
4272 |
+ char *buf2 = 0 ; |
|
4273 |
+ int alloc2 = 0 ; |
|
4274 |
+ int argvi = 0; |
|
4275 |
+ dXSARGS; |
|
4276 |
+ |
|
4277 |
+ if ((items < 2) || (items > 2)) {
|
|
4278 |
+ SWIG_croak("Usage: userstr_t_qualifier_set(self,qualifier);");
|
|
4279 |
+ } |
|
4280 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4281 |
+ if (!SWIG_IsOK(res1)) {
|
|
4282 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_qualifier_set" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4283 |
+ } |
|
4284 |
+ arg1 = (userstr_t *)(argp1); |
|
4285 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4286 |
+ if (!SWIG_IsOK(res2)) {
|
|
4287 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userstr_t_qualifier_set" "', argument " "2"" of type '" "char *""'"); |
|
4288 |
+ } |
|
4289 |
+ arg2 = (char *)(buf2); |
|
4290 |
+ if (arg1->qualifier) free((char*)arg1->qualifier); |
|
4291 |
+ if (arg2) {
|
|
4292 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4293 |
+ arg1->qualifier = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4294 |
+ } else {
|
|
4295 |
+ arg1->qualifier = 0; |
|
4296 |
+ } |
|
4297 |
+ |
|
4298 |
+ |
|
4299 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4300 |
+ XSRETURN(argvi); |
|
4301 |
+ fail: |
|
4302 |
+ |
|
4303 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4304 |
+ SWIG_croak_null(); |
|
4305 |
+ } |
|
4306 |
+} |
|
4307 |
+ |
|
4308 |
+ |
|
4309 |
+XS(_wrap_userstr_t_qualifier_get) {
|
|
4310 |
+ {
|
|
4311 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4312 |
+ char *result = 0 ; |
|
4313 |
+ void *argp1 = 0 ; |
|
4314 |
+ int res1 = 0 ; |
|
4315 |
+ int argvi = 0; |
|
4316 |
+ dXSARGS; |
|
4317 |
+ |
|
4318 |
+ if ((items < 1) || (items > 1)) {
|
|
4319 |
+ SWIG_croak("Usage: userstr_t_qualifier_get(self);");
|
|
4320 |
+ } |
|
4321 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4322 |
+ if (!SWIG_IsOK(res1)) {
|
|
4323 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_qualifier_get" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4324 |
+ } |
|
4325 |
+ arg1 = (userstr_t *)(argp1); |
|
4326 |
+ result = (char *) ((arg1)->qualifier); |
|
4327 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4328 |
+ |
|
4329 |
+ XSRETURN(argvi); |
|
4330 |
+ fail: |
|
4331 |
+ |
|
4332 |
+ SWIG_croak_null(); |
|
4333 |
+ } |
|
4334 |
+} |
|
4335 |
+ |
|
4336 |
+ |
|
4337 |
+XS(_wrap_userstr_t_res1_set) {
|
|
4338 |
+ {
|
|
4339 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4340 |
+ char *arg2 = (char *) 0 ; |
|
4341 |
+ void *argp1 = 0 ; |
|
4342 |
+ int res1 = 0 ; |
|
4343 |
+ int res2 ; |
|
4344 |
+ char *buf2 = 0 ; |
|
4345 |
+ int alloc2 = 0 ; |
|
4346 |
+ int argvi = 0; |
|
4347 |
+ dXSARGS; |
|
4348 |
+ |
|
4349 |
+ if ((items < 2) || (items > 2)) {
|
|
4350 |
+ SWIG_croak("Usage: userstr_t_res1_set(self,res1);");
|
|
4351 |
+ } |
|
4352 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4353 |
+ if (!SWIG_IsOK(res1)) {
|
|
4354 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_res1_set" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4355 |
+ } |
|
4356 |
+ arg1 = (userstr_t *)(argp1); |
|
4357 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4358 |
+ if (!SWIG_IsOK(res2)) {
|
|
4359 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userstr_t_res1_set" "', argument " "2"" of type '" "char *""'"); |
|
4360 |
+ } |
|
4361 |
+ arg2 = (char *)(buf2); |
|
4362 |
+ if (arg1->res1) free((char*)arg1->res1); |
|
4363 |
+ if (arg2) {
|
|
4364 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4365 |
+ arg1->res1 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4366 |
+ } else {
|
|
4367 |
+ arg1->res1 = 0; |
|
4368 |
+ } |
|
4369 |
+ |
|
4370 |
+ |
|
4371 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4372 |
+ XSRETURN(argvi); |
|
4373 |
+ fail: |
|
4374 |
+ |
|
4375 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4376 |
+ SWIG_croak_null(); |
|
4377 |
+ } |
|
4378 |
+} |
|
4379 |
+ |
|
4380 |
+ |
|
4381 |
+XS(_wrap_userstr_t_res1_get) {
|
|
4382 |
+ {
|
|
4383 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4384 |
+ char *result = 0 ; |
|
4385 |
+ void *argp1 = 0 ; |
|
4386 |
+ int res1 = 0 ; |
|
4387 |
+ int argvi = 0; |
|
4388 |
+ dXSARGS; |
|
4389 |
+ |
|
4390 |
+ if ((items < 1) || (items > 1)) {
|
|
4391 |
+ SWIG_croak("Usage: userstr_t_res1_get(self);");
|
|
4392 |
+ } |
|
4393 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4394 |
+ if (!SWIG_IsOK(res1)) {
|
|
4395 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_res1_get" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4396 |
+ } |
|
4397 |
+ arg1 = (userstr_t *)(argp1); |
|
4398 |
+ result = (char *) ((arg1)->res1); |
|
4399 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4400 |
+ |
|
4401 |
+ XSRETURN(argvi); |
|
4402 |
+ fail: |
|
4403 |
+ |
|
4404 |
+ SWIG_croak_null(); |
|
4405 |
+ } |
|
4406 |
+} |
|
4407 |
+ |
|
4408 |
+ |
|
4409 |
+XS(_wrap_userstr_t_res2_set) {
|
|
4410 |
+ {
|
|
4411 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4412 |
+ char *arg2 = (char *) 0 ; |
|
4413 |
+ void *argp1 = 0 ; |
|
4414 |
+ int res1 = 0 ; |
|
4415 |
+ int res2 ; |
|
4416 |
+ char *buf2 = 0 ; |
|
4417 |
+ int alloc2 = 0 ; |
|
4418 |
+ int argvi = 0; |
|
4419 |
+ dXSARGS; |
|
4420 |
+ |
|
4421 |
+ if ((items < 2) || (items > 2)) {
|
|
4422 |
+ SWIG_croak("Usage: userstr_t_res2_set(self,res2);");
|
|
4423 |
+ } |
|
4424 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4425 |
+ if (!SWIG_IsOK(res1)) {
|
|
4426 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_res2_set" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4427 |
+ } |
|
4428 |
+ arg1 = (userstr_t *)(argp1); |
|
4429 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4430 |
+ if (!SWIG_IsOK(res2)) {
|
|
4431 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userstr_t_res2_set" "', argument " "2"" of type '" "char *""'"); |
|
4432 |
+ } |
|
4433 |
+ arg2 = (char *)(buf2); |
|
4434 |
+ if (arg1->res2) free((char*)arg1->res2); |
|
4435 |
+ if (arg2) {
|
|
4436 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4437 |
+ arg1->res2 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4438 |
+ } else {
|
|
4439 |
+ arg1->res2 = 0; |
|
4440 |
+ } |
|
4441 |
+ |
|
4442 |
+ |
|
4443 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4444 |
+ XSRETURN(argvi); |
|
4445 |
+ fail: |
|
4446 |
+ |
|
4447 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4448 |
+ SWIG_croak_null(); |
|
4449 |
+ } |
|
4450 |
+} |
|
4451 |
+ |
|
4452 |
+ |
|
4453 |
+XS(_wrap_userstr_t_res2_get) {
|
|
4454 |
+ {
|
|
4455 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4456 |
+ char *result = 0 ; |
|
4457 |
+ void *argp1 = 0 ; |
|
4458 |
+ int res1 = 0 ; |
|
4459 |
+ int argvi = 0; |
|
4460 |
+ dXSARGS; |
|
4461 |
+ |
|
4462 |
+ if ((items < 1) || (items > 1)) {
|
|
4463 |
+ SWIG_croak("Usage: userstr_t_res2_get(self);");
|
|
4464 |
+ } |
|
4465 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4466 |
+ if (!SWIG_IsOK(res1)) {
|
|
4467 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_res2_get" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4468 |
+ } |
|
4469 |
+ arg1 = (userstr_t *)(argp1); |
|
4470 |
+ result = (char *) ((arg1)->res2); |
|
4471 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4472 |
+ |
|
4473 |
+ XSRETURN(argvi); |
|
4474 |
+ fail: |
|
4475 |
+ |
|
4476 |
+ SWIG_croak_null(); |
|
4477 |
+ } |
|
4478 |
+} |
|
4479 |
+ |
|
4480 |
+ |
|
4481 |
+XS(_wrap_userstr_t_attr_set) {
|
|
4482 |
+ {
|
|
4483 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4484 |
+ char *arg2 = (char *) 0 ; |
|
4485 |
+ void *argp1 = 0 ; |
|
4486 |
+ int res1 = 0 ; |
|
4487 |
+ int res2 ; |
|
4488 |
+ char *buf2 = 0 ; |
|
4489 |
+ int alloc2 = 0 ; |
|
4490 |
+ int argvi = 0; |
|
4491 |
+ dXSARGS; |
|
4492 |
+ |
|
4493 |
+ if ((items < 2) || (items > 2)) {
|
|
4494 |
+ SWIG_croak("Usage: userstr_t_attr_set(self,attr);");
|
|
4495 |
+ } |
|
4496 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4497 |
+ if (!SWIG_IsOK(res1)) {
|
|
4498 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_attr_set" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4499 |
+ } |
|
4500 |
+ arg1 = (userstr_t *)(argp1); |
|
4501 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4502 |
+ if (!SWIG_IsOK(res2)) {
|
|
4503 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userstr_t_attr_set" "', argument " "2"" of type '" "char *""'"); |
|
4504 |
+ } |
|
4505 |
+ arg2 = (char *)(buf2); |
|
4506 |
+ if (arg1->attr) free((char*)arg1->attr); |
|
4507 |
+ if (arg2) {
|
|
4508 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4509 |
+ arg1->attr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4510 |
+ } else {
|
|
4511 |
+ arg1->attr = 0; |
|
4512 |
+ } |
|
4513 |
+ |
|
4514 |
+ |
|
4515 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4516 |
+ XSRETURN(argvi); |
|
4517 |
+ fail: |
|
4518 |
+ |
|
4519 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4520 |
+ SWIG_croak_null(); |
|
4521 |
+ } |
|
4522 |
+} |
|
4523 |
+ |
|
4524 |
+ |
|
4525 |
+XS(_wrap_userstr_t_attr_get) {
|
|
4526 |
+ {
|
|
4527 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4528 |
+ char *result = 0 ; |
|
4529 |
+ void *argp1 = 0 ; |
|
4530 |
+ int res1 = 0 ; |
|
4531 |
+ int argvi = 0; |
|
4532 |
+ dXSARGS; |
|
4533 |
+ |
|
4534 |
+ if ((items < 1) || (items > 1)) {
|
|
4535 |
+ SWIG_croak("Usage: userstr_t_attr_get(self);");
|
|
4536 |
+ } |
|
4537 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, 0 | 0 ); |
|
4538 |
+ if (!SWIG_IsOK(res1)) {
|
|
4539 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userstr_t_attr_get" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4540 |
+ } |
|
4541 |
+ arg1 = (userstr_t *)(argp1); |
|
4542 |
+ result = (char *) ((arg1)->attr); |
|
4543 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4544 |
+ |
|
4545 |
+ XSRETURN(argvi); |
|
4546 |
+ fail: |
|
4547 |
+ |
|
4548 |
+ SWIG_croak_null(); |
|
4549 |
+ } |
|
4550 |
+} |
|
4551 |
+ |
|
4552 |
+ |
|
4553 |
+XS(_wrap_new_userstr_t) {
|
|
4554 |
+ {
|
|
4555 |
+ userstr_t *result = 0 ; |
|
4556 |
+ int argvi = 0; |
|
4557 |
+ dXSARGS; |
|
4558 |
+ |
|
4559 |
+ if ((items < 0) || (items > 0)) {
|
|
4560 |
+ SWIG_croak("Usage: new_userstr_t();");
|
|
4561 |
+ } |
|
4562 |
+ result = (userstr_t *)calloc(1, sizeof(userstr_t)); |
|
4563 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userstr_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
4564 |
+ XSRETURN(argvi); |
|
4565 |
+ fail: |
|
4566 |
+ SWIG_croak_null(); |
|
4567 |
+ } |
|
4568 |
+} |
|
4569 |
+ |
|
4570 |
+ |
|
4571 |
+XS(_wrap_delete_userstr_t) {
|
|
4572 |
+ {
|
|
4573 |
+ userstr_t *arg1 = (userstr_t *) 0 ; |
|
4574 |
+ void *argp1 = 0 ; |
|
4575 |
+ int res1 = 0 ; |
|
4576 |
+ int argvi = 0; |
|
4577 |
+ dXSARGS; |
|
4578 |
+ |
|
4579 |
+ if ((items < 1) || (items > 1)) {
|
|
4580 |
+ SWIG_croak("Usage: delete_userstr_t(self);");
|
|
4581 |
+ } |
|
4582 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userstr_s, SWIG_POINTER_DISOWN | 0 ); |
|
4583 |
+ if (!SWIG_IsOK(res1)) {
|
|
4584 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_userstr_t" "', argument " "1"" of type '" "userstr_t *""'"); |
|
4585 |
+ } |
|
4586 |
+ arg1 = (userstr_t *)(argp1); |
|
4587 |
+ free((char *) arg1); |
|
4588 |
+ |
|
4589 |
+ |
|
4590 |
+ |
|
4591 |
+ XSRETURN(argvi); |
|
4592 |
+ fail: |
|
4593 |
+ |
|
4594 |
+ SWIG_croak_null(); |
|
4595 |
+ } |
|
4596 |
+} |
|
4597 |
+ |
|
4598 |
+ |
|
4599 |
+XS(_wrap_userattr_t_name_set) {
|
|
4600 |
+ {
|
|
4601 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4602 |
+ char *arg2 = (char *) 0 ; |
|
4603 |
+ void *argp1 = 0 ; |
|
4604 |
+ int res1 = 0 ; |
|
4605 |
+ int res2 ; |
|
4606 |
+ char *buf2 = 0 ; |
|
4607 |
+ int alloc2 = 0 ; |
|
4608 |
+ int argvi = 0; |
|
4609 |
+ dXSARGS; |
|
4610 |
+ |
|
4611 |
+ if ((items < 2) || (items > 2)) {
|
|
4612 |
+ SWIG_croak("Usage: userattr_t_name_set(self,name);");
|
|
4613 |
+ } |
|
4614 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4615 |
+ if (!SWIG_IsOK(res1)) {
|
|
4616 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_name_set" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4617 |
+ } |
|
4618 |
+ arg1 = (userattr_t *)(argp1); |
|
4619 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4620 |
+ if (!SWIG_IsOK(res2)) {
|
|
4621 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userattr_t_name_set" "', argument " "2"" of type '" "char *""'"); |
|
4622 |
+ } |
|
4623 |
+ arg2 = (char *)(buf2); |
|
4624 |
+ if (arg1->name) free((char*)arg1->name); |
|
4625 |
+ if (arg2) {
|
|
4626 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4627 |
+ arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4628 |
+ } else {
|
|
4629 |
+ arg1->name = 0; |
|
4630 |
+ } |
|
4631 |
+ |
|
4632 |
+ |
|
4633 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4634 |
+ XSRETURN(argvi); |
|
4635 |
+ fail: |
|
4636 |
+ |
|
4637 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4638 |
+ SWIG_croak_null(); |
|
4639 |
+ } |
|
4640 |
+} |
|
4641 |
+ |
|
4642 |
+ |
|
4643 |
+XS(_wrap_userattr_t_name_get) {
|
|
4644 |
+ {
|
|
4645 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4646 |
+ char *result = 0 ; |
|
4647 |
+ void *argp1 = 0 ; |
|
4648 |
+ int res1 = 0 ; |
|
4649 |
+ int argvi = 0; |
|
4650 |
+ dXSARGS; |
|
4651 |
+ |
|
4652 |
+ if ((items < 1) || (items > 1)) {
|
|
4653 |
+ SWIG_croak("Usage: userattr_t_name_get(self);");
|
|
4654 |
+ } |
|
4655 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4656 |
+ if (!SWIG_IsOK(res1)) {
|
|
4657 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_name_get" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4658 |
+ } |
|
4659 |
+ arg1 = (userattr_t *)(argp1); |
|
4660 |
+ result = (char *) ((arg1)->name); |
|
4661 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4662 |
+ |
|
4663 |
+ XSRETURN(argvi); |
|
4664 |
+ fail: |
|
4665 |
+ |
|
4666 |
+ SWIG_croak_null(); |
|
4667 |
+ } |
|
4668 |
+} |
|
4669 |
+ |
|
4670 |
+ |
|
4671 |
+XS(_wrap_userattr_t_qualifier_set) {
|
|
4672 |
+ {
|
|
4673 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4674 |
+ char *arg2 = (char *) 0 ; |
|
4675 |
+ void *argp1 = 0 ; |
|
4676 |
+ int res1 = 0 ; |
|
4677 |
+ int res2 ; |
|
4678 |
+ char *buf2 = 0 ; |
|
4679 |
+ int alloc2 = 0 ; |
|
4680 |
+ int argvi = 0; |
|
4681 |
+ dXSARGS; |
|
4682 |
+ |
|
4683 |
+ if ((items < 2) || (items > 2)) {
|
|
4684 |
+ SWIG_croak("Usage: userattr_t_qualifier_set(self,qualifier);");
|
|
4685 |
+ } |
|
4686 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4687 |
+ if (!SWIG_IsOK(res1)) {
|
|
4688 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_qualifier_set" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4689 |
+ } |
|
4690 |
+ arg1 = (userattr_t *)(argp1); |
|
4691 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4692 |
+ if (!SWIG_IsOK(res2)) {
|
|
4693 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userattr_t_qualifier_set" "', argument " "2"" of type '" "char *""'"); |
|
4694 |
+ } |
|
4695 |
+ arg2 = (char *)(buf2); |
|
4696 |
+ if (arg1->qualifier) free((char*)arg1->qualifier); |
|
4697 |
+ if (arg2) {
|
|
4698 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4699 |
+ arg1->qualifier = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4700 |
+ } else {
|
|
4701 |
+ arg1->qualifier = 0; |
|
4702 |
+ } |
|
4703 |
+ |
|
4704 |
+ |
|
4705 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4706 |
+ XSRETURN(argvi); |
|
4707 |
+ fail: |
|
4708 |
+ |
|
4709 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4710 |
+ SWIG_croak_null(); |
|
4711 |
+ } |
|
4712 |
+} |
|
4713 |
+ |
|
4714 |
+ |
|
4715 |
+XS(_wrap_userattr_t_qualifier_get) {
|
|
4716 |
+ {
|
|
4717 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4718 |
+ char *result = 0 ; |
|
4719 |
+ void *argp1 = 0 ; |
|
4720 |
+ int res1 = 0 ; |
|
4721 |
+ int argvi = 0; |
|
4722 |
+ dXSARGS; |
|
4723 |
+ |
|
4724 |
+ if ((items < 1) || (items > 1)) {
|
|
4725 |
+ SWIG_croak("Usage: userattr_t_qualifier_get(self);");
|
|
4726 |
+ } |
|
4727 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4728 |
+ if (!SWIG_IsOK(res1)) {
|
|
4729 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_qualifier_get" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4730 |
+ } |
|
4731 |
+ arg1 = (userattr_t *)(argp1); |
|
4732 |
+ result = (char *) ((arg1)->qualifier); |
|
4733 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4734 |
+ |
|
4735 |
+ XSRETURN(argvi); |
|
4736 |
+ fail: |
|
4737 |
+ |
|
4738 |
+ SWIG_croak_null(); |
|
4739 |
+ } |
|
4740 |
+} |
|
4741 |
+ |
|
4742 |
+ |
|
4743 |
+XS(_wrap_userattr_t_res1_set) {
|
|
4744 |
+ {
|
|
4745 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4746 |
+ char *arg2 = (char *) 0 ; |
|
4747 |
+ void *argp1 = 0 ; |
|
4748 |
+ int res1 = 0 ; |
|
4749 |
+ int res2 ; |
|
4750 |
+ char *buf2 = 0 ; |
|
4751 |
+ int alloc2 = 0 ; |
|
4752 |
+ int argvi = 0; |
|
4753 |
+ dXSARGS; |
|
4754 |
+ |
|
4755 |
+ if ((items < 2) || (items > 2)) {
|
|
4756 |
+ SWIG_croak("Usage: userattr_t_res1_set(self,res1);");
|
|
4757 |
+ } |
|
4758 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4759 |
+ if (!SWIG_IsOK(res1)) {
|
|
4760 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_res1_set" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4761 |
+ } |
|
4762 |
+ arg1 = (userattr_t *)(argp1); |
|
4763 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4764 |
+ if (!SWIG_IsOK(res2)) {
|
|
4765 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userattr_t_res1_set" "', argument " "2"" of type '" "char *""'"); |
|
4766 |
+ } |
|
4767 |
+ arg2 = (char *)(buf2); |
|
4768 |
+ if (arg1->res1) free((char*)arg1->res1); |
|
4769 |
+ if (arg2) {
|
|
4770 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4771 |
+ arg1->res1 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4772 |
+ } else {
|
|
4773 |
+ arg1->res1 = 0; |
|
4774 |
+ } |
|
4775 |
+ |
|
4776 |
+ |
|
4777 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4778 |
+ XSRETURN(argvi); |
|
4779 |
+ fail: |
|
4780 |
+ |
|
4781 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4782 |
+ SWIG_croak_null(); |
|
4783 |
+ } |
|
4784 |
+} |
|
4785 |
+ |
|
4786 |
+ |
|
4787 |
+XS(_wrap_userattr_t_res1_get) {
|
|
4788 |
+ {
|
|
4789 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4790 |
+ char *result = 0 ; |
|
4791 |
+ void *argp1 = 0 ; |
|
4792 |
+ int res1 = 0 ; |
|
4793 |
+ int argvi = 0; |
|
4794 |
+ dXSARGS; |
|
4795 |
+ |
|
4796 |
+ if ((items < 1) || (items > 1)) {
|
|
4797 |
+ SWIG_croak("Usage: userattr_t_res1_get(self);");
|
|
4798 |
+ } |
|
4799 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4800 |
+ if (!SWIG_IsOK(res1)) {
|
|
4801 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_res1_get" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4802 |
+ } |
|
4803 |
+ arg1 = (userattr_t *)(argp1); |
|
4804 |
+ result = (char *) ((arg1)->res1); |
|
4805 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4806 |
+ |
|
4807 |
+ XSRETURN(argvi); |
|
4808 |
+ fail: |
|
4809 |
+ |
|
4810 |
+ SWIG_croak_null(); |
|
4811 |
+ } |
|
4812 |
+} |
|
4813 |
+ |
|
4814 |
+ |
|
4815 |
+XS(_wrap_userattr_t_res2_set) {
|
|
4816 |
+ {
|
|
4817 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4818 |
+ char *arg2 = (char *) 0 ; |
|
4819 |
+ void *argp1 = 0 ; |
|
4820 |
+ int res1 = 0 ; |
|
4821 |
+ int res2 ; |
|
4822 |
+ char *buf2 = 0 ; |
|
4823 |
+ int alloc2 = 0 ; |
|
4824 |
+ int argvi = 0; |
|
4825 |
+ dXSARGS; |
|
4826 |
+ |
|
4827 |
+ if ((items < 2) || (items > 2)) {
|
|
4828 |
+ SWIG_croak("Usage: userattr_t_res2_set(self,res2);");
|
|
4829 |
+ } |
|
4830 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4831 |
+ if (!SWIG_IsOK(res1)) {
|
|
4832 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_res2_set" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4833 |
+ } |
|
4834 |
+ arg1 = (userattr_t *)(argp1); |
|
4835 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
4836 |
+ if (!SWIG_IsOK(res2)) {
|
|
4837 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userattr_t_res2_set" "', argument " "2"" of type '" "char *""'"); |
|
4838 |
+ } |
|
4839 |
+ arg2 = (char *)(buf2); |
|
4840 |
+ if (arg1->res2) free((char*)arg1->res2); |
|
4841 |
+ if (arg2) {
|
|
4842 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
4843 |
+ arg1->res2 = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
4844 |
+ } else {
|
|
4845 |
+ arg1->res2 = 0; |
|
4846 |
+ } |
|
4847 |
+ |
|
4848 |
+ |
|
4849 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4850 |
+ XSRETURN(argvi); |
|
4851 |
+ fail: |
|
4852 |
+ |
|
4853 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
4854 |
+ SWIG_croak_null(); |
|
4855 |
+ } |
|
4856 |
+} |
|
4857 |
+ |
|
4858 |
+ |
|
4859 |
+XS(_wrap_userattr_t_res2_get) {
|
|
4860 |
+ {
|
|
4861 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4862 |
+ char *result = 0 ; |
|
4863 |
+ void *argp1 = 0 ; |
|
4864 |
+ int res1 = 0 ; |
|
4865 |
+ int argvi = 0; |
|
4866 |
+ dXSARGS; |
|
4867 |
+ |
|
4868 |
+ if ((items < 1) || (items > 1)) {
|
|
4869 |
+ SWIG_croak("Usage: userattr_t_res2_get(self);");
|
|
4870 |
+ } |
|
4871 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4872 |
+ if (!SWIG_IsOK(res1)) {
|
|
4873 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_res2_get" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4874 |
+ } |
|
4875 |
+ arg1 = (userattr_t *)(argp1); |
|
4876 |
+ result = (char *) ((arg1)->res2); |
|
4877 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
4878 |
+ |
|
4879 |
+ XSRETURN(argvi); |
|
4880 |
+ fail: |
|
4881 |
+ |
|
4882 |
+ SWIG_croak_null(); |
|
4883 |
+ } |
|
4884 |
+} |
|
4885 |
+ |
|
4886 |
+ |
|
4887 |
+XS(_wrap_userattr_t_attr_set) {
|
|
4888 |
+ {
|
|
4889 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4890 |
+ kva_t *arg2 = (kva_t *) 0 ; |
|
4891 |
+ void *argp1 = 0 ; |
|
4892 |
+ int res1 = 0 ; |
|
4893 |
+ void *argp2 = 0 ; |
|
4894 |
+ int res2 = 0 ; |
|
4895 |
+ int argvi = 0; |
|
4896 |
+ dXSARGS; |
|
4897 |
+ |
|
4898 |
+ if ((items < 2) || (items > 2)) {
|
|
4899 |
+ SWIG_croak("Usage: userattr_t_attr_set(self,attr);");
|
|
4900 |
+ } |
|
4901 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4902 |
+ if (!SWIG_IsOK(res1)) {
|
|
4903 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_attr_set" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4904 |
+ } |
|
4905 |
+ arg1 = (userattr_t *)(argp1); |
|
4906 |
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_kva_s, SWIG_POINTER_DISOWN | 0 ); |
|
4907 |
+ if (!SWIG_IsOK(res2)) {
|
|
4908 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "userattr_t_attr_set" "', argument " "2"" of type '" "kva_t *""'"); |
|
4909 |
+ } |
|
4910 |
+ arg2 = (kva_t *)(argp2); |
|
4911 |
+ if (arg1) (arg1)->attr = arg2; |
|
4912 |
+ |
|
4913 |
+ |
|
4914 |
+ |
|
4915 |
+ |
|
4916 |
+ XSRETURN(argvi); |
|
4917 |
+ fail: |
|
4918 |
+ |
|
4919 |
+ |
|
4920 |
+ SWIG_croak_null(); |
|
4921 |
+ } |
|
4922 |
+} |
|
4923 |
+ |
|
4924 |
+ |
|
4925 |
+XS(_wrap_userattr_t_attr_get) {
|
|
4926 |
+ {
|
|
4927 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4928 |
+ kva_t *result = 0 ; |
|
4929 |
+ void *argp1 = 0 ; |
|
4930 |
+ int res1 = 0 ; |
|
4931 |
+ int argvi = 0; |
|
4932 |
+ dXSARGS; |
|
4933 |
+ |
|
4934 |
+ if ((items < 1) || (items > 1)) {
|
|
4935 |
+ SWIG_croak("Usage: userattr_t_attr_get(self);");
|
|
4936 |
+ } |
|
4937 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
4938 |
+ if (!SWIG_IsOK(res1)) {
|
|
4939 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "userattr_t_attr_get" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4940 |
+ } |
|
4941 |
+ arg1 = (userattr_t *)(argp1); |
|
4942 |
+ result = (kva_t *) ((arg1)->attr); |
|
4943 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, 0 | SWIG_SHADOW); argvi++ ; |
|
4944 |
+ |
|
4945 |
+ XSRETURN(argvi); |
|
4946 |
+ fail: |
|
4947 |
+ |
|
4948 |
+ SWIG_croak_null(); |
|
4949 |
+ } |
|
4950 |
+} |
|
4951 |
+ |
|
4952 |
+ |
|
4953 |
+XS(_wrap_new_userattr_t) {
|
|
4954 |
+ {
|
|
4955 |
+ userattr_t *result = 0 ; |
|
4956 |
+ int argvi = 0; |
|
4957 |
+ dXSARGS; |
|
4958 |
+ |
|
4959 |
+ if ((items < 0) || (items > 0)) {
|
|
4960 |
+ SWIG_croak("Usage: new_userattr_t();");
|
|
4961 |
+ } |
|
4962 |
+ result = (userattr_t *)calloc(1, sizeof(userattr_t)); |
|
4963 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userattr_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
4964 |
+ XSRETURN(argvi); |
|
4965 |
+ fail: |
|
4966 |
+ SWIG_croak_null(); |
|
4967 |
+ } |
|
4968 |
+} |
|
4969 |
+ |
|
4970 |
+ |
|
4971 |
+XS(_wrap_delete_userattr_t) {
|
|
4972 |
+ {
|
|
4973 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
4974 |
+ void *argp1 = 0 ; |
|
4975 |
+ int res1 = 0 ; |
|
4976 |
+ int argvi = 0; |
|
4977 |
+ dXSARGS; |
|
4978 |
+ |
|
4979 |
+ if ((items < 1) || (items > 1)) {
|
|
4980 |
+ SWIG_croak("Usage: delete_userattr_t(self);");
|
|
4981 |
+ } |
|
4982 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, SWIG_POINTER_DISOWN | 0 ); |
|
4983 |
+ if (!SWIG_IsOK(res1)) {
|
|
4984 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_userattr_t" "', argument " "1"" of type '" "userattr_t *""'"); |
|
4985 |
+ } |
|
4986 |
+ arg1 = (userattr_t *)(argp1); |
|
4987 |
+ free((char *) arg1); |
|
4988 |
+ |
|
4989 |
+ |
|
4990 |
+ |
|
4991 |
+ XSRETURN(argvi); |
|
4992 |
+ fail: |
|
4993 |
+ |
|
4994 |
+ SWIG_croak_null(); |
|
4995 |
+ } |
|
4996 |
+} |
|
4997 |
+ |
|
4998 |
+ |
|
4999 |
+XS(_wrap_getusernam) {
|
|
5000 |
+ {
|
|
5001 |
+ char *arg1 = (char *) 0 ; |
|
5002 |
+ userattr_t *result = 0 ; |
|
5003 |
+ int res1 ; |
|
5004 |
+ char *buf1 = 0 ; |
|
5005 |
+ int alloc1 = 0 ; |
|
5006 |
+ int argvi = 0; |
|
5007 |
+ dXSARGS; |
|
5008 |
+ |
|
5009 |
+ if ((items < 1) || (items > 1)) {
|
|
5010 |
+ SWIG_croak("Usage: getusernam(char const *);");
|
|
5011 |
+ } |
|
5012 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
5013 |
+ if (!SWIG_IsOK(res1)) {
|
|
5014 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getusernam" "', argument " "1"" of type '" "char const *""'"); |
|
5015 |
+ } |
|
5016 |
+ arg1 = (char *)(buf1); |
|
5017 |
+ result = (userattr_t *)getusernam((char const *)arg1); |
|
5018 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5019 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5020 |
+ XSRETURN(argvi); |
|
5021 |
+ fail: |
|
5022 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5023 |
+ SWIG_croak_null(); |
|
5024 |
+ } |
|
5025 |
+} |
|
5026 |
+ |
|
5027 |
+ |
|
5028 |
+XS(_wrap_getuseruid) {
|
|
5029 |
+ {
|
|
5030 |
+ uid_t arg1 ; |
|
5031 |
+ userattr_t *result = 0 ; |
|
5032 |
+ void *argp1 ; |
|
5033 |
+ int res1 = 0 ; |
|
5034 |
+ int argvi = 0; |
|
5035 |
+ dXSARGS; |
|
5036 |
+ |
|
5037 |
+ if ((items < 1) || (items > 1)) {
|
|
5038 |
+ SWIG_croak("Usage: getuseruid(uid);");
|
|
5039 |
+ } |
|
5040 |
+ {
|
|
5041 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_uid_t, 0 ); |
|
5042 |
+ if (!SWIG_IsOK(res1)) {
|
|
5043 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getuseruid" "', argument " "1"" of type '" "uid_t""'"); |
|
5044 |
+ } |
|
5045 |
+ if (!argp1) {
|
|
5046 |
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getuseruid" "', argument " "1"" of type '" "uid_t""'"); |
|
5047 |
+ } else {
|
|
5048 |
+ arg1 = *((uid_t *)(argp1)); |
|
5049 |
+ } |
|
5050 |
+ } |
|
5051 |
+ result = (userattr_t *)getuseruid(arg1); |
|
5052 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5053 |
+ XSRETURN(argvi); |
|
5054 |
+ fail: |
|
5055 |
+ SWIG_croak_null(); |
|
5056 |
+ } |
|
5057 |
+} |
|
5058 |
+ |
|
5059 |
+ |
|
5060 |
+XS(_wrap_getuserattr) {
|
|
5061 |
+ {
|
|
5062 |
+ userattr_t *result = 0 ; |
|
5063 |
+ int argvi = 0; |
|
5064 |
+ dXSARGS; |
|
5065 |
+ |
|
5066 |
+ if ((items < 0) || (items > 0)) {
|
|
5067 |
+ SWIG_croak("Usage: getuserattr();");
|
|
5068 |
+ } |
|
5069 |
+ result = (userattr_t *)getuserattr(); |
|
5070 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5071 |
+ XSRETURN(argvi); |
|
5072 |
+ fail: |
|
5073 |
+ SWIG_croak_null(); |
|
5074 |
+ } |
|
5075 |
+} |
|
5076 |
+ |
|
5077 |
+ |
|
5078 |
+XS(_wrap_fgetuserattr) {
|
|
5079 |
+ {
|
|
5080 |
+ struct __FILE *arg1 = (struct __FILE *) 0 ; |
|
5081 |
+ userattr_t *result = 0 ; |
|
5082 |
+ void *argp1 = 0 ; |
|
5083 |
+ int res1 = 0 ; |
|
5084 |
+ int argvi = 0; |
|
5085 |
+ dXSARGS; |
|
5086 |
+ |
|
5087 |
+ if ((items < 1) || (items > 1)) {
|
|
5088 |
+ SWIG_croak("Usage: fgetuserattr(struct __FILE *);");
|
|
5089 |
+ } |
|
5090 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p___FILE, 0 | 0 ); |
|
5091 |
+ if (!SWIG_IsOK(res1)) {
|
|
5092 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fgetuserattr" "', argument " "1"" of type '" "struct __FILE *""'"); |
|
5093 |
+ } |
|
5094 |
+ arg1 = (struct __FILE *)(argp1); |
|
5095 |
+ result = (userattr_t *)fgetuserattr(arg1); |
|
5096 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_userattr_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5097 |
+ |
|
5098 |
+ XSRETURN(argvi); |
|
5099 |
+ fail: |
|
5100 |
+ |
|
5101 |
+ SWIG_croak_null(); |
|
5102 |
+ } |
|
5103 |
+} |
|
5104 |
+ |
|
5105 |
+ |
|
5106 |
+XS(_wrap_setuserattr) {
|
|
5107 |
+ {
|
|
5108 |
+ int argvi = 0; |
|
5109 |
+ dXSARGS; |
|
5110 |
+ |
|
5111 |
+ if ((items < 0) || (items > 0)) {
|
|
5112 |
+ SWIG_croak("Usage: setuserattr();");
|
|
5113 |
+ } |
|
5114 |
+ setuserattr(); |
|
5115 |
+ |
|
5116 |
+ XSRETURN(argvi); |
|
5117 |
+ fail: |
|
5118 |
+ SWIG_croak_null(); |
|
5119 |
+ } |
|
5120 |
+} |
|
5121 |
+ |
|
5122 |
+ |
|
5123 |
+XS(_wrap_enduserattr) {
|
|
5124 |
+ {
|
|
5125 |
+ int argvi = 0; |
|
5126 |
+ dXSARGS; |
|
5127 |
+ |
|
5128 |
+ if ((items < 0) || (items > 0)) {
|
|
5129 |
+ SWIG_croak("Usage: enduserattr();");
|
|
5130 |
+ } |
|
5131 |
+ enduserattr(); |
|
5132 |
+ |
|
5133 |
+ XSRETURN(argvi); |
|
5134 |
+ fail: |
|
5135 |
+ SWIG_croak_null(); |
|
5136 |
+ } |
|
5137 |
+} |
|
5138 |
+ |
|
5139 |
+ |
|
5140 |
+XS(_wrap_free_userattr) {
|
|
5141 |
+ {
|
|
5142 |
+ userattr_t *arg1 = (userattr_t *) 0 ; |
|
5143 |
+ void *argp1 = 0 ; |
|
5144 |
+ int res1 = 0 ; |
|
5145 |
+ int argvi = 0; |
|
5146 |
+ dXSARGS; |
|
5147 |
+ |
|
5148 |
+ if ((items < 1) || (items > 1)) {
|
|
5149 |
+ SWIG_croak("Usage: free_userattr(userattr_t *);");
|
|
5150 |
+ } |
|
5151 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_userattr_s, 0 | 0 ); |
|
5152 |
+ if (!SWIG_IsOK(res1)) {
|
|
5153 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_userattr" "', argument " "1"" of type '" "userattr_t *""'"); |
|
5154 |
+ } |
|
5155 |
+ arg1 = (userattr_t *)(argp1); |
|
5156 |
+ free_userattr(arg1); |
|
5157 |
+ |
|
5158 |
+ |
|
5159 |
+ XSRETURN(argvi); |
|
5160 |
+ fail: |
|
5161 |
+ |
|
5162 |
+ SWIG_croak_null(); |
|
5163 |
+ } |
|
5164 |
+} |
|
5165 |
+ |
|
5166 |
+ |
|
5167 |
+XS(_wrap_kv_t_key_set) {
|
|
5168 |
+ {
|
|
5169 |
+ kv_t *arg1 = (kv_t *) 0 ; |
|
5170 |
+ char *arg2 = (char *) 0 ; |
|
5171 |
+ void *argp1 = 0 ; |
|
5172 |
+ int res1 = 0 ; |
|
5173 |
+ int res2 ; |
|
5174 |
+ char *buf2 = 0 ; |
|
5175 |
+ int alloc2 = 0 ; |
|
5176 |
+ int argvi = 0; |
|
5177 |
+ dXSARGS; |
|
5178 |
+ |
|
5179 |
+ if ((items < 2) || (items > 2)) {
|
|
5180 |
+ SWIG_croak("Usage: kv_t_key_set(self,key);");
|
|
5181 |
+ } |
|
5182 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kv_s, 0 | 0 ); |
|
5183 |
+ if (!SWIG_IsOK(res1)) {
|
|
5184 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kv_t_key_set" "', argument " "1"" of type '" "kv_t *""'"); |
|
5185 |
+ } |
|
5186 |
+ arg1 = (kv_t *)(argp1); |
|
5187 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5188 |
+ if (!SWIG_IsOK(res2)) {
|
|
5189 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kv_t_key_set" "', argument " "2"" of type '" "char *""'"); |
|
5190 |
+ } |
|
5191 |
+ arg2 = (char *)(buf2); |
|
5192 |
+ if (arg1->key) free((char*)arg1->key); |
|
5193 |
+ if (arg2) {
|
|
5194 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
5195 |
+ arg1->key = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
5196 |
+ } else {
|
|
5197 |
+ arg1->key = 0; |
|
5198 |
+ } |
|
5199 |
+ |
|
5200 |
+ |
|
5201 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5202 |
+ XSRETURN(argvi); |
|
5203 |
+ fail: |
|
5204 |
+ |
|
5205 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5206 |
+ SWIG_croak_null(); |
|
5207 |
+ } |
|
5208 |
+} |
|
5209 |
+ |
|
5210 |
+ |
|
5211 |
+XS(_wrap_kv_t_key_get) {
|
|
5212 |
+ {
|
|
5213 |
+ kv_t *arg1 = (kv_t *) 0 ; |
|
5214 |
+ char *result = 0 ; |
|
5215 |
+ void *argp1 = 0 ; |
|
5216 |
+ int res1 = 0 ; |
|
5217 |
+ int argvi = 0; |
|
5218 |
+ dXSARGS; |
|
5219 |
+ |
|
5220 |
+ if ((items < 1) || (items > 1)) {
|
|
5221 |
+ SWIG_croak("Usage: kv_t_key_get(self);");
|
|
5222 |
+ } |
|
5223 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kv_s, 0 | 0 ); |
|
5224 |
+ if (!SWIG_IsOK(res1)) {
|
|
5225 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kv_t_key_get" "', argument " "1"" of type '" "kv_t *""'"); |
|
5226 |
+ } |
|
5227 |
+ arg1 = (kv_t *)(argp1); |
|
5228 |
+ result = (char *) ((arg1)->key); |
|
5229 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
5230 |
+ |
|
5231 |
+ XSRETURN(argvi); |
|
5232 |
+ fail: |
|
5233 |
+ |
|
5234 |
+ SWIG_croak_null(); |
|
5235 |
+ } |
|
5236 |
+} |
|
5237 |
+ |
|
5238 |
+ |
|
5239 |
+XS(_wrap_kv_t_value_set) {
|
|
5240 |
+ {
|
|
5241 |
+ kv_t *arg1 = (kv_t *) 0 ; |
|
5242 |
+ char *arg2 = (char *) 0 ; |
|
5243 |
+ void *argp1 = 0 ; |
|
5244 |
+ int res1 = 0 ; |
|
5245 |
+ int res2 ; |
|
5246 |
+ char *buf2 = 0 ; |
|
5247 |
+ int alloc2 = 0 ; |
|
5248 |
+ int argvi = 0; |
|
5249 |
+ dXSARGS; |
|
5250 |
+ |
|
5251 |
+ if ((items < 2) || (items > 2)) {
|
|
5252 |
+ SWIG_croak("Usage: kv_t_value_set(self,value);");
|
|
5253 |
+ } |
|
5254 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kv_s, 0 | 0 ); |
|
5255 |
+ if (!SWIG_IsOK(res1)) {
|
|
5256 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kv_t_value_set" "', argument " "1"" of type '" "kv_t *""'"); |
|
5257 |
+ } |
|
5258 |
+ arg1 = (kv_t *)(argp1); |
|
5259 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5260 |
+ if (!SWIG_IsOK(res2)) {
|
|
5261 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kv_t_value_set" "', argument " "2"" of type '" "char *""'"); |
|
5262 |
+ } |
|
5263 |
+ arg2 = (char *)(buf2); |
|
5264 |
+ if (arg1->value) free((char*)arg1->value); |
|
5265 |
+ if (arg2) {
|
|
5266 |
+ size_t size = strlen((const char *)(arg2)) + 1; |
|
5267 |
+ arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size)); |
|
5268 |
+ } else {
|
|
5269 |
+ arg1->value = 0; |
|
5270 |
+ } |
|
5271 |
+ |
|
5272 |
+ |
|
5273 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5274 |
+ XSRETURN(argvi); |
|
5275 |
+ fail: |
|
5276 |
+ |
|
5277 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5278 |
+ SWIG_croak_null(); |
|
5279 |
+ } |
|
5280 |
+} |
|
5281 |
+ |
|
5282 |
+ |
|
5283 |
+XS(_wrap_kv_t_value_get) {
|
|
5284 |
+ {
|
|
5285 |
+ kv_t *arg1 = (kv_t *) 0 ; |
|
5286 |
+ char *result = 0 ; |
|
5287 |
+ void *argp1 = 0 ; |
|
5288 |
+ int res1 = 0 ; |
|
5289 |
+ int argvi = 0; |
|
5290 |
+ dXSARGS; |
|
5291 |
+ |
|
5292 |
+ if ((items < 1) || (items > 1)) {
|
|
5293 |
+ SWIG_croak("Usage: kv_t_value_get(self);");
|
|
5294 |
+ } |
|
5295 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kv_s, 0 | 0 ); |
|
5296 |
+ if (!SWIG_IsOK(res1)) {
|
|
5297 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kv_t_value_get" "', argument " "1"" of type '" "kv_t *""'"); |
|
5298 |
+ } |
|
5299 |
+ arg1 = (kv_t *)(argp1); |
|
5300 |
+ result = (char *) ((arg1)->value); |
|
5301 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
5302 |
+ |
|
5303 |
+ XSRETURN(argvi); |
|
5304 |
+ fail: |
|
5305 |
+ |
|
5306 |
+ SWIG_croak_null(); |
|
5307 |
+ } |
|
5308 |
+} |
|
5309 |
+ |
|
5310 |
+ |
|
5311 |
+XS(_wrap_new_kv_t) {
|
|
5312 |
+ {
|
|
5313 |
+ kv_t *result = 0 ; |
|
5314 |
+ int argvi = 0; |
|
5315 |
+ dXSARGS; |
|
5316 |
+ |
|
5317 |
+ if ((items < 0) || (items > 0)) {
|
|
5318 |
+ SWIG_croak("Usage: new_kv_t();");
|
|
5319 |
+ } |
|
5320 |
+ result = (kv_t *)calloc(1, sizeof(kv_t)); |
|
5321 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kv_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
5322 |
+ XSRETURN(argvi); |
|
5323 |
+ fail: |
|
5324 |
+ SWIG_croak_null(); |
|
5325 |
+ } |
|
5326 |
+} |
|
5327 |
+ |
|
5328 |
+ |
|
5329 |
+XS(_wrap_delete_kv_t) {
|
|
5330 |
+ {
|
|
5331 |
+ kv_t *arg1 = (kv_t *) 0 ; |
|
5332 |
+ void *argp1 = 0 ; |
|
5333 |
+ int res1 = 0 ; |
|
5334 |
+ int argvi = 0; |
|
5335 |
+ dXSARGS; |
|
5336 |
+ |
|
5337 |
+ if ((items < 1) || (items > 1)) {
|
|
5338 |
+ SWIG_croak("Usage: delete_kv_t(self);");
|
|
5339 |
+ } |
|
5340 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kv_s, SWIG_POINTER_DISOWN | 0 ); |
|
5341 |
+ if (!SWIG_IsOK(res1)) {
|
|
5342 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kv_t" "', argument " "1"" of type '" "kv_t *""'"); |
|
5343 |
+ } |
|
5344 |
+ arg1 = (kv_t *)(argp1); |
|
5345 |
+ free((char *) arg1); |
|
5346 |
+ |
|
5347 |
+ |
|
5348 |
+ |
|
5349 |
+ XSRETURN(argvi); |
|
5350 |
+ fail: |
|
5351 |
+ |
|
5352 |
+ SWIG_croak_null(); |
|
5353 |
+ } |
|
5354 |
+} |
|
5355 |
+ |
|
5356 |
+ |
|
5357 |
+XS(_wrap_kva_t_length_set) {
|
|
5358 |
+ {
|
|
5359 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5360 |
+ int arg2 ; |
|
5361 |
+ void *argp1 = 0 ; |
|
5362 |
+ int res1 = 0 ; |
|
5363 |
+ int val2 ; |
|
5364 |
+ int ecode2 = 0 ; |
|
5365 |
+ int argvi = 0; |
|
5366 |
+ dXSARGS; |
|
5367 |
+ |
|
5368 |
+ if ((items < 2) || (items > 2)) {
|
|
5369 |
+ SWIG_croak("Usage: kva_t_length_set(self,length);");
|
|
5370 |
+ } |
|
5371 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5372 |
+ if (!SWIG_IsOK(res1)) {
|
|
5373 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kva_t_length_set" "', argument " "1"" of type '" "kva_t *""'"); |
|
5374 |
+ } |
|
5375 |
+ arg1 = (kva_t *)(argp1); |
|
5376 |
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2); |
|
5377 |
+ if (!SWIG_IsOK(ecode2)) {
|
|
5378 |
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kva_t_length_set" "', argument " "2"" of type '" "int""'"); |
|
5379 |
+ } |
|
5380 |
+ arg2 = (int)(val2); |
|
5381 |
+ if (arg1) (arg1)->length = arg2; |
|
5382 |
+ |
|
5383 |
+ |
|
5384 |
+ |
|
5385 |
+ |
|
5386 |
+ XSRETURN(argvi); |
|
5387 |
+ fail: |
|
5388 |
+ |
|
5389 |
+ |
|
5390 |
+ SWIG_croak_null(); |
|
5391 |
+ } |
|
5392 |
+} |
|
5393 |
+ |
|
5394 |
+ |
|
5395 |
+XS(_wrap_kva_t_length_get) {
|
|
5396 |
+ {
|
|
5397 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5398 |
+ int result; |
|
5399 |
+ void *argp1 = 0 ; |
|
5400 |
+ int res1 = 0 ; |
|
5401 |
+ int argvi = 0; |
|
5402 |
+ dXSARGS; |
|
5403 |
+ |
|
5404 |
+ if ((items < 1) || (items > 1)) {
|
|
5405 |
+ SWIG_croak("Usage: kva_t_length_get(self);");
|
|
5406 |
+ } |
|
5407 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5408 |
+ if (!SWIG_IsOK(res1)) {
|
|
5409 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kva_t_length_get" "', argument " "1"" of type '" "kva_t *""'"); |
|
5410 |
+ } |
|
5411 |
+ arg1 = (kva_t *)(argp1); |
|
5412 |
+ result = (int) ((arg1)->length); |
|
5413 |
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ; |
|
5414 |
+ |
|
5415 |
+ XSRETURN(argvi); |
|
5416 |
+ fail: |
|
5417 |
+ |
|
5418 |
+ SWIG_croak_null(); |
|
5419 |
+ } |
|
5420 |
+} |
|
5421 |
+ |
|
5422 |
+ |
|
5423 |
+XS(_wrap_kva_t_data_set) {
|
|
5424 |
+ {
|
|
5425 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5426 |
+ kv_t *arg2 = (kv_t *) 0 ; |
|
5427 |
+ void *argp1 = 0 ; |
|
5428 |
+ int res1 = 0 ; |
|
5429 |
+ void *argp2 = 0 ; |
|
5430 |
+ int res2 = 0 ; |
|
5431 |
+ int argvi = 0; |
|
5432 |
+ dXSARGS; |
|
5433 |
+ |
|
5434 |
+ if ((items < 2) || (items > 2)) {
|
|
5435 |
+ SWIG_croak("Usage: kva_t_data_set(self,data);");
|
|
5436 |
+ } |
|
5437 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5438 |
+ if (!SWIG_IsOK(res1)) {
|
|
5439 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kva_t_data_set" "', argument " "1"" of type '" "kva_t *""'"); |
|
5440 |
+ } |
|
5441 |
+ arg1 = (kva_t *)(argp1); |
|
5442 |
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_kv_s, SWIG_POINTER_DISOWN | 0 ); |
|
5443 |
+ if (!SWIG_IsOK(res2)) {
|
|
5444 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kva_t_data_set" "', argument " "2"" of type '" "kv_t *""'"); |
|
5445 |
+ } |
|
5446 |
+ arg2 = (kv_t *)(argp2); |
|
5447 |
+ if (arg1) (arg1)->data = arg2; |
|
5448 |
+ |
|
5449 |
+ |
|
5450 |
+ |
|
5451 |
+ |
|
5452 |
+ XSRETURN(argvi); |
|
5453 |
+ fail: |
|
5454 |
+ |
|
5455 |
+ |
|
5456 |
+ SWIG_croak_null(); |
|
5457 |
+ } |
|
5458 |
+} |
|
5459 |
+ |
|
5460 |
+ |
|
5461 |
+XS(_wrap_kva_t_data_get) {
|
|
5462 |
+ {
|
|
5463 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5464 |
+ kv_t *result = 0 ; |
|
5465 |
+ void *argp1 = 0 ; |
|
5466 |
+ int res1 = 0 ; |
|
5467 |
+ int argvi = 0; |
|
5468 |
+ dXSARGS; |
|
5469 |
+ |
|
5470 |
+ if ((items < 1) || (items > 1)) {
|
|
5471 |
+ SWIG_croak("Usage: kva_t_data_get(self);");
|
|
5472 |
+ } |
|
5473 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5474 |
+ if (!SWIG_IsOK(res1)) {
|
|
5475 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kva_t_data_get" "', argument " "1"" of type '" "kva_t *""'"); |
|
5476 |
+ } |
|
5477 |
+ arg1 = (kva_t *)(argp1); |
|
5478 |
+ result = (kv_t *) ((arg1)->data); |
|
5479 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kv_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5480 |
+ |
|
5481 |
+ XSRETURN(argvi); |
|
5482 |
+ fail: |
|
5483 |
+ |
|
5484 |
+ SWIG_croak_null(); |
|
5485 |
+ } |
|
5486 |
+} |
|
5487 |
+ |
|
5488 |
+ |
|
5489 |
+XS(_wrap_new_kva_t) {
|
|
5490 |
+ {
|
|
5491 |
+ kva_t *result = 0 ; |
|
5492 |
+ int argvi = 0; |
|
5493 |
+ dXSARGS; |
|
5494 |
+ |
|
5495 |
+ if ((items < 0) || (items > 0)) {
|
|
5496 |
+ SWIG_croak("Usage: new_kva_t();");
|
|
5497 |
+ } |
|
5498 |
+ result = (kva_t *)calloc(1, sizeof(kva_t)); |
|
5499 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, SWIG_OWNER | SWIG_SHADOW); argvi++ ; |
|
5500 |
+ XSRETURN(argvi); |
|
5501 |
+ fail: |
|
5502 |
+ SWIG_croak_null(); |
|
5503 |
+ } |
|
5504 |
+} |
|
5505 |
+ |
|
5506 |
+ |
|
5507 |
+XS(_wrap_delete_kva_t) {
|
|
5508 |
+ {
|
|
5509 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5510 |
+ void *argp1 = 0 ; |
|
5511 |
+ int res1 = 0 ; |
|
5512 |
+ int argvi = 0; |
|
5513 |
+ dXSARGS; |
|
5514 |
+ |
|
5515 |
+ if ((items < 1) || (items > 1)) {
|
|
5516 |
+ SWIG_croak("Usage: delete_kva_t(self);");
|
|
5517 |
+ } |
|
5518 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, SWIG_POINTER_DISOWN | 0 ); |
|
5519 |
+ if (!SWIG_IsOK(res1)) {
|
|
5520 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kva_t" "', argument " "1"" of type '" "kva_t *""'"); |
|
5521 |
+ } |
|
5522 |
+ arg1 = (kva_t *)(argp1); |
|
5523 |
+ free((char *) arg1); |
|
5524 |
+ |
|
5525 |
+ |
|
5526 |
+ |
|
5527 |
+ XSRETURN(argvi); |
|
5528 |
+ fail: |
|
5529 |
+ |
|
5530 |
+ SWIG_croak_null(); |
|
5531 |
+ } |
|
5532 |
+} |
|
5533 |
+ |
|
5534 |
+ |
|
5535 |
+XS(_wrap_kva_match) {
|
|
5536 |
+ {
|
|
5537 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5538 |
+ char *arg2 = (char *) 0 ; |
|
5539 |
+ char *result = 0 ; |
|
5540 |
+ void *argp1 = 0 ; |
|
5541 |
+ int res1 = 0 ; |
|
5542 |
+ int res2 ; |
|
5543 |
+ char *buf2 = 0 ; |
|
5544 |
+ int alloc2 = 0 ; |
|
5545 |
+ int argvi = 0; |
|
5546 |
+ dXSARGS; |
|
5547 |
+ |
|
5548 |
+ if ((items < 2) || (items > 2)) {
|
|
5549 |
+ SWIG_croak("Usage: kva_match(kva_t *,char *);");
|
|
5550 |
+ } |
|
5551 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5552 |
+ if (!SWIG_IsOK(res1)) {
|
|
5553 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kva_match" "', argument " "1"" of type '" "kva_t *""'"); |
|
5554 |
+ } |
|
5555 |
+ arg1 = (kva_t *)(argp1); |
|
5556 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5557 |
+ if (!SWIG_IsOK(res2)) {
|
|
5558 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kva_match" "', argument " "2"" of type '" "char *""'"); |
|
5559 |
+ } |
|
5560 |
+ arg2 = (char *)(buf2); |
|
5561 |
+ result = (char *)kva_match(arg1,arg2); |
|
5562 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
5563 |
+ |
|
5564 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5565 |
+ XSRETURN(argvi); |
|
5566 |
+ fail: |
|
5567 |
+ |
|
5568 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5569 |
+ SWIG_croak_null(); |
|
5570 |
+ } |
|
5571 |
+} |
|
5572 |
+ |
|
5573 |
+ |
|
5574 |
+XS(_wrap__auth_match) {
|
|
5575 |
+ {
|
|
5576 |
+ char *arg1 = (char *) 0 ; |
|
5577 |
+ char *arg2 = (char *) 0 ; |
|
5578 |
+ int result; |
|
5579 |
+ int res1 ; |
|
5580 |
+ char *buf1 = 0 ; |
|
5581 |
+ int alloc1 = 0 ; |
|
5582 |
+ int res2 ; |
|
5583 |
+ char *buf2 = 0 ; |
|
5584 |
+ int alloc2 = 0 ; |
|
5585 |
+ int argvi = 0; |
|
5586 |
+ dXSARGS; |
|
5587 |
+ |
|
5588 |
+ if ((items < 2) || (items > 2)) {
|
|
5589 |
+ SWIG_croak("Usage: _auth_match(char const *,char const *);");
|
|
5590 |
+ } |
|
5591 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
5592 |
+ if (!SWIG_IsOK(res1)) {
|
|
5593 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_auth_match" "', argument " "1"" of type '" "char const *""'"); |
|
5594 |
+ } |
|
5595 |
+ arg1 = (char *)(buf1); |
|
5596 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5597 |
+ if (!SWIG_IsOK(res2)) {
|
|
5598 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_auth_match" "', argument " "2"" of type '" "char const *""'"); |
|
5599 |
+ } |
|
5600 |
+ arg2 = (char *)(buf2); |
|
5601 |
+ result = (int)_auth_match((char const *)arg1,(char const *)arg2); |
|
5602 |
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ; |
|
5603 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5604 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5605 |
+ XSRETURN(argvi); |
|
5606 |
+ fail: |
|
5607 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5608 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5609 |
+ SWIG_croak_null(); |
|
5610 |
+ } |
|
5611 |
+} |
|
5612 |
+ |
|
5613 |
+ |
|
5614 |
+XS(_wrap__argv_to_csl) {
|
|
5615 |
+ {
|
|
5616 |
+ char **arg1 = (char **) 0 ; |
|
5617 |
+ char *result = 0 ; |
|
5618 |
+ void *argp1 = 0 ; |
|
5619 |
+ int res1 = 0 ; |
|
5620 |
+ int argvi = 0; |
|
5621 |
+ dXSARGS; |
|
5622 |
+ |
|
5623 |
+ if ((items < 1) || (items > 1)) {
|
|
5624 |
+ SWIG_croak("Usage: _argv_to_csl(strings);");
|
|
5625 |
+ } |
|
5626 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_char, 0 | 0 ); |
|
5627 |
+ if (!SWIG_IsOK(res1)) {
|
|
5628 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_argv_to_csl" "', argument " "1"" of type '" "char **""'"); |
|
5629 |
+ } |
|
5630 |
+ arg1 = (char **)(argp1); |
|
5631 |
+ result = (char *)_argv_to_csl(arg1); |
|
5632 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
5633 |
+ |
|
5634 |
+ XSRETURN(argvi); |
|
5635 |
+ fail: |
|
5636 |
+ |
|
5637 |
+ SWIG_croak_null(); |
|
5638 |
+ } |
|
5639 |
+} |
|
5640 |
+ |
|
5641 |
+ |
|
5642 |
+XS(_wrap__csl_to_argv) {
|
|
5643 |
+ {
|
|
5644 |
+ char *arg1 = (char *) 0 ; |
|
5645 |
+ char **result = 0 ; |
|
5646 |
+ int res1 ; |
|
5647 |
+ char *buf1 = 0 ; |
|
5648 |
+ int alloc1 = 0 ; |
|
5649 |
+ int argvi = 0; |
|
5650 |
+ dXSARGS; |
|
5651 |
+ |
|
5652 |
+ if ((items < 1) || (items > 1)) {
|
|
5653 |
+ SWIG_croak("Usage: _csl_to_argv(csl);");
|
|
5654 |
+ } |
|
5655 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
5656 |
+ if (!SWIG_IsOK(res1)) {
|
|
5657 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_csl_to_argv" "', argument " "1"" of type '" "char *""'"); |
|
5658 |
+ } |
|
5659 |
+ arg1 = (char *)(buf1); |
|
5660 |
+ result = (char **)_csl_to_argv(arg1); |
|
5661 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0); argvi++ ; |
|
5662 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5663 |
+ XSRETURN(argvi); |
|
5664 |
+ fail: |
|
5665 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5666 |
+ SWIG_croak_null(); |
|
5667 |
+ } |
|
5668 |
+} |
|
5669 |
+ |
|
5670 |
+ |
|
5671 |
+XS(_wrap__do_unescape) {
|
|
5672 |
+ {
|
|
5673 |
+ char *arg1 = (char *) 0 ; |
|
5674 |
+ char *result = 0 ; |
|
5675 |
+ int res1 ; |
|
5676 |
+ char *buf1 = 0 ; |
|
5677 |
+ int alloc1 = 0 ; |
|
5678 |
+ int argvi = 0; |
|
5679 |
+ dXSARGS; |
|
5680 |
+ |
|
5681 |
+ if ((items < 1) || (items > 1)) {
|
|
5682 |
+ SWIG_croak("Usage: _do_unescape(src);");
|
|
5683 |
+ } |
|
5684 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
5685 |
+ if (!SWIG_IsOK(res1)) {
|
|
5686 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_do_unescape" "', argument " "1"" of type '" "char *""'"); |
|
5687 |
+ } |
|
5688 |
+ arg1 = (char *)(buf1); |
|
5689 |
+ result = (char *)_do_unescape(arg1); |
|
5690 |
+ ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; |
|
5691 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5692 |
+ XSRETURN(argvi); |
|
5693 |
+ fail: |
|
5694 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5695 |
+ SWIG_croak_null(); |
|
5696 |
+ } |
|
5697 |
+} |
|
5698 |
+ |
|
5699 |
+ |
|
5700 |
+XS(_wrap__free_argv) {
|
|
5701 |
+ {
|
|
5702 |
+ char **arg1 = (char **) 0 ; |
|
5703 |
+ void *argp1 = 0 ; |
|
5704 |
+ int res1 = 0 ; |
|
5705 |
+ int argvi = 0; |
|
5706 |
+ dXSARGS; |
|
5707 |
+ |
|
5708 |
+ if ((items < 1) || (items > 1)) {
|
|
5709 |
+ SWIG_croak("Usage: _free_argv(p_argv);");
|
|
5710 |
+ } |
|
5711 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p_char, 0 | 0 ); |
|
5712 |
+ if (!SWIG_IsOK(res1)) {
|
|
5713 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_free_argv" "', argument " "1"" of type '" "char **""'"); |
|
5714 |
+ } |
|
5715 |
+ arg1 = (char **)(argp1); |
|
5716 |
+ _free_argv(arg1); |
|
5717 |
+ |
|
5718 |
+ |
|
5719 |
+ XSRETURN(argvi); |
|
5720 |
+ fail: |
|
5721 |
+ |
|
5722 |
+ SWIG_croak_null(); |
|
5723 |
+ } |
|
5724 |
+} |
|
5725 |
+ |
|
5726 |
+ |
|
5727 |
+XS(_wrap__insert2kva) {
|
|
5728 |
+ {
|
|
5729 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5730 |
+ char *arg2 = (char *) 0 ; |
|
5731 |
+ char *arg3 = (char *) 0 ; |
|
5732 |
+ int result; |
|
5733 |
+ void *argp1 = 0 ; |
|
5734 |
+ int res1 = 0 ; |
|
5735 |
+ int res2 ; |
|
5736 |
+ char *buf2 = 0 ; |
|
5737 |
+ int alloc2 = 0 ; |
|
5738 |
+ int res3 ; |
|
5739 |
+ char *buf3 = 0 ; |
|
5740 |
+ int alloc3 = 0 ; |
|
5741 |
+ int argvi = 0; |
|
5742 |
+ dXSARGS; |
|
5743 |
+ |
|
5744 |
+ if ((items < 3) || (items > 3)) {
|
|
5745 |
+ SWIG_croak("Usage: _insert2kva(kva_t *,char *,char *);");
|
|
5746 |
+ } |
|
5747 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5748 |
+ if (!SWIG_IsOK(res1)) {
|
|
5749 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_insert2kva" "', argument " "1"" of type '" "kva_t *""'"); |
|
5750 |
+ } |
|
5751 |
+ arg1 = (kva_t *)(argp1); |
|
5752 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5753 |
+ if (!SWIG_IsOK(res2)) {
|
|
5754 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_insert2kva" "', argument " "2"" of type '" "char *""'"); |
|
5755 |
+ } |
|
5756 |
+ arg2 = (char *)(buf2); |
|
5757 |
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3); |
|
5758 |
+ if (!SWIG_IsOK(res3)) {
|
|
5759 |
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_insert2kva" "', argument " "3"" of type '" "char *""'"); |
|
5760 |
+ } |
|
5761 |
+ arg3 = (char *)(buf3); |
|
5762 |
+ result = (int)_insert2kva(arg1,arg2,arg3); |
|
5763 |
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ; |
|
5764 |
+ |
|
5765 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5766 |
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); |
|
5767 |
+ XSRETURN(argvi); |
|
5768 |
+ fail: |
|
5769 |
+ |
|
5770 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5771 |
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); |
|
5772 |
+ SWIG_croak_null(); |
|
5773 |
+ } |
|
5774 |
+} |
|
5775 |
+ |
|
5776 |
+ |
|
5777 |
+XS(_wrap__kva2str) {
|
|
5778 |
+ {
|
|
5779 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5780 |
+ char *arg2 = (char *) 0 ; |
|
5781 |
+ int arg3 ; |
|
5782 |
+ char *arg4 = (char *) 0 ; |
|
5783 |
+ char *arg5 = (char *) 0 ; |
|
5784 |
+ int result; |
|
5785 |
+ void *argp1 = 0 ; |
|
5786 |
+ int res1 = 0 ; |
|
5787 |
+ int res2 ; |
|
5788 |
+ char *buf2 = 0 ; |
|
5789 |
+ int alloc2 = 0 ; |
|
5790 |
+ int val3 ; |
|
5791 |
+ int ecode3 = 0 ; |
|
5792 |
+ int res4 ; |
|
5793 |
+ char *buf4 = 0 ; |
|
5794 |
+ int alloc4 = 0 ; |
|
5795 |
+ int res5 ; |
|
5796 |
+ char *buf5 = 0 ; |
|
5797 |
+ int alloc5 = 0 ; |
|
5798 |
+ int argvi = 0; |
|
5799 |
+ dXSARGS; |
|
5800 |
+ |
|
5801 |
+ if ((items < 5) || (items > 5)) {
|
|
5802 |
+ SWIG_croak("Usage: _kva2str(kva_t *,char *,int,char *,char *);");
|
|
5803 |
+ } |
|
5804 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5805 |
+ if (!SWIG_IsOK(res1)) {
|
|
5806 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_kva2str" "', argument " "1"" of type '" "kva_t *""'"); |
|
5807 |
+ } |
|
5808 |
+ arg1 = (kva_t *)(argp1); |
|
5809 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5810 |
+ if (!SWIG_IsOK(res2)) {
|
|
5811 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_kva2str" "', argument " "2"" of type '" "char *""'"); |
|
5812 |
+ } |
|
5813 |
+ arg2 = (char *)(buf2); |
|
5814 |
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3); |
|
5815 |
+ if (!SWIG_IsOK(ecode3)) {
|
|
5816 |
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "_kva2str" "', argument " "3"" of type '" "int""'"); |
|
5817 |
+ } |
|
5818 |
+ arg3 = (int)(val3); |
|
5819 |
+ res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4); |
|
5820 |
+ if (!SWIG_IsOK(res4)) {
|
|
5821 |
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "_kva2str" "', argument " "4"" of type '" "char *""'"); |
|
5822 |
+ } |
|
5823 |
+ arg4 = (char *)(buf4); |
|
5824 |
+ res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5); |
|
5825 |
+ if (!SWIG_IsOK(res5)) {
|
|
5826 |
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "_kva2str" "', argument " "5"" of type '" "char *""'"); |
|
5827 |
+ } |
|
5828 |
+ arg5 = (char *)(buf5); |
|
5829 |
+ result = (int)_kva2str(arg1,arg2,arg3,arg4,arg5); |
|
5830 |
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ; |
|
5831 |
+ |
|
5832 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5833 |
+ |
|
5834 |
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); |
|
5835 |
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); |
|
5836 |
+ XSRETURN(argvi); |
|
5837 |
+ fail: |
|
5838 |
+ |
|
5839 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5840 |
+ |
|
5841 |
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); |
|
5842 |
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); |
|
5843 |
+ SWIG_croak_null(); |
|
5844 |
+ } |
|
5845 |
+} |
|
5846 |
+ |
|
5847 |
+ |
|
5848 |
+XS(_wrap__kva_dup) {
|
|
5849 |
+ {
|
|
5850 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5851 |
+ kva_t *result = 0 ; |
|
5852 |
+ void *argp1 = 0 ; |
|
5853 |
+ int res1 = 0 ; |
|
5854 |
+ int argvi = 0; |
|
5855 |
+ dXSARGS; |
|
5856 |
+ |
|
5857 |
+ if ((items < 1) || (items > 1)) {
|
|
5858 |
+ SWIG_croak("Usage: _kva_dup(kva_t *);");
|
|
5859 |
+ } |
|
5860 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5861 |
+ if (!SWIG_IsOK(res1)) {
|
|
5862 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_kva_dup" "', argument " "1"" of type '" "kva_t *""'"); |
|
5863 |
+ } |
|
5864 |
+ arg1 = (kva_t *)(argp1); |
|
5865 |
+ result = (kva_t *)_kva_dup(arg1); |
|
5866 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5867 |
+ |
|
5868 |
+ XSRETURN(argvi); |
|
5869 |
+ fail: |
|
5870 |
+ |
|
5871 |
+ SWIG_croak_null(); |
|
5872 |
+ } |
|
5873 |
+} |
|
5874 |
+ |
|
5875 |
+ |
|
5876 |
+XS(_wrap__kva_free) {
|
|
5877 |
+ {
|
|
5878 |
+ kva_t *arg1 = (kva_t *) 0 ; |
|
5879 |
+ void *argp1 = 0 ; |
|
5880 |
+ int res1 = 0 ; |
|
5881 |
+ int argvi = 0; |
|
5882 |
+ dXSARGS; |
|
5883 |
+ |
|
5884 |
+ if ((items < 1) || (items > 1)) {
|
|
5885 |
+ SWIG_croak("Usage: _kva_free(kva_t *);");
|
|
5886 |
+ } |
|
5887 |
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_kva_s, 0 | 0 ); |
|
5888 |
+ if (!SWIG_IsOK(res1)) {
|
|
5889 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_kva_free" "', argument " "1"" of type '" "kva_t *""'"); |
|
5890 |
+ } |
|
5891 |
+ arg1 = (kva_t *)(argp1); |
|
5892 |
+ _kva_free(arg1); |
|
5893 |
+ |
|
5894 |
+ |
|
5895 |
+ XSRETURN(argvi); |
|
5896 |
+ fail: |
|
5897 |
+ |
|
5898 |
+ SWIG_croak_null(); |
|
5899 |
+ } |
|
5900 |
+} |
|
5901 |
+ |
|
5902 |
+ |
|
5903 |
+XS(_wrap__new_kva) {
|
|
5904 |
+ {
|
|
5905 |
+ int arg1 ; |
|
5906 |
+ kva_t *result = 0 ; |
|
5907 |
+ int val1 ; |
|
5908 |
+ int ecode1 = 0 ; |
|
5909 |
+ int argvi = 0; |
|
5910 |
+ dXSARGS; |
|
5911 |
+ |
|
5912 |
+ if ((items < 1) || (items > 1)) {
|
|
5913 |
+ SWIG_croak("Usage: _new_kva(size);");
|
|
5914 |
+ } |
|
5915 |
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1); |
|
5916 |
+ if (!SWIG_IsOK(ecode1)) {
|
|
5917 |
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_new_kva" "', argument " "1"" of type '" "int""'"); |
|
5918 |
+ } |
|
5919 |
+ arg1 = (int)(val1); |
|
5920 |
+ result = (kva_t *)_new_kva(arg1); |
|
5921 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5922 |
+ |
|
5923 |
+ XSRETURN(argvi); |
|
5924 |
+ fail: |
|
5925 |
+ |
|
5926 |
+ SWIG_croak_null(); |
|
5927 |
+ } |
|
5928 |
+} |
|
5929 |
+ |
|
5930 |
+ |
|
5931 |
+XS(_wrap__str2kva) {
|
|
5932 |
+ {
|
|
5933 |
+ char *arg1 = (char *) 0 ; |
|
5934 |
+ char *arg2 = (char *) 0 ; |
|
5935 |
+ char *arg3 = (char *) 0 ; |
|
5936 |
+ kva_t *result = 0 ; |
|
5937 |
+ int res1 ; |
|
5938 |
+ char *buf1 = 0 ; |
|
5939 |
+ int alloc1 = 0 ; |
|
5940 |
+ int res2 ; |
|
5941 |
+ char *buf2 = 0 ; |
|
5942 |
+ int alloc2 = 0 ; |
|
5943 |
+ int res3 ; |
|
5944 |
+ char *buf3 = 0 ; |
|
5945 |
+ int alloc3 = 0 ; |
|
5946 |
+ int argvi = 0; |
|
5947 |
+ dXSARGS; |
|
5948 |
+ |
|
5949 |
+ if ((items < 3) || (items > 3)) {
|
|
5950 |
+ SWIG_croak("Usage: _str2kva(char *,char *,char *);");
|
|
5951 |
+ } |
|
5952 |
+ res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1); |
|
5953 |
+ if (!SWIG_IsOK(res1)) {
|
|
5954 |
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_str2kva" "', argument " "1"" of type '" "char *""'"); |
|
5955 |
+ } |
|
5956 |
+ arg1 = (char *)(buf1); |
|
5957 |
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); |
|
5958 |
+ if (!SWIG_IsOK(res2)) {
|
|
5959 |
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_str2kva" "', argument " "2"" of type '" "char *""'"); |
|
5960 |
+ } |
|
5961 |
+ arg2 = (char *)(buf2); |
|
5962 |
+ res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3); |
|
5963 |
+ if (!SWIG_IsOK(res3)) {
|
|
5964 |
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "_str2kva" "', argument " "3"" of type '" "char *""'"); |
|
5965 |
+ } |
|
5966 |
+ arg3 = (char *)(buf3); |
|
5967 |
+ result = (kva_t *)_str2kva(arg1,arg2,arg3); |
|
5968 |
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kva_s, 0 | SWIG_SHADOW); argvi++ ; |
|
5969 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5970 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5971 |
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); |
|
5972 |
+ XSRETURN(argvi); |
|
5973 |
+ fail: |
|
5974 |
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); |
|
5975 |
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); |
|
5976 |
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); |
|
5977 |
+ SWIG_croak_null(); |
|
5978 |
+ } |
|
5979 |
+} |
|
5980 |
+ |
|
5981 |
+ |
|
5982 |
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ |
|
5983 |
+ |
|
5984 |
+static swig_type_info _swigt__p___FILE = {"_p___FILE", "struct __FILE *", 0, 0, (void*)0, 0};
|
|
5985 |
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
|
|
5986 |
+static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
|
|
5987 |
+static swig_type_info _swigt__p_kv_s = {"_p_kv_s", "struct kv_s *|kv_t *", 0, 0, (void*)"secdb::kv_t", 0};
|
|
5988 |
+static swig_type_info _swigt__p_kva_s = {"_p_kva_s", "struct kva_s *|kva_t *", 0, 0, (void*)"secdb::kva_t", 0};
|
|
5989 |
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
|
|
5990 |
+static swig_type_info _swigt__p_profattr_s = {"_p_profattr_s", "profattr_t *|struct profattr_s *", 0, 0, (void*)"secdb::profattr_t", 0};
|
|
5991 |
+static swig_type_info _swigt__p_profstr_s = {"_p_profstr_s", "struct profstr_s *|profstr_t *", 0, 0, (void*)"secdb::profstr_t", 0};
|
|
5992 |
+static swig_type_info _swigt__p_uid_t = {"_p_uid_t", "uid_t *", 0, 0, (void*)0, 0};
|
|
5993 |
+static swig_type_info _swigt__p_userattr_s = {"_p_userattr_s", "userattr_t *|struct userattr_s *", 0, 0, (void*)"secdb::userattr_t", 0};
|
|
5994 |
+static swig_type_info _swigt__p_userstr_s = {"_p_userstr_s", "struct userstr_s *|userstr_t *", 0, 0, (void*)"secdb::userstr_t", 0};
|
|
5995 |
+ |
|
5996 |
+static swig_type_info *swig_type_initial[] = {
|
|
5997 |
+ &_swigt__p___FILE, |
|
5998 |
+ &_swigt__p_char, |
|
5999 |
+ &_swigt__p_int, |
|
6000 |
+ &_swigt__p_kv_s, |
|
6001 |
+ &_swigt__p_kva_s, |
|
6002 |
+ &_swigt__p_p_char, |
|
6003 |
+ &_swigt__p_profattr_s, |
|
6004 |
+ &_swigt__p_profstr_s, |
|
6005 |
+ &_swigt__p_uid_t, |
|
6006 |
+ &_swigt__p_userattr_s, |
|
6007 |
+ &_swigt__p_userstr_s, |
|
6008 |
+}; |
|
6009 |
+ |
|
6010 |
+static swig_cast_info _swigc__p___FILE[] = { {&_swigt__p___FILE, 0, 0, 0},{0, 0, 0, 0}};
|
|
6011 |
+static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
|
|
6012 |
+static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
|
|
6013 |
+static swig_cast_info _swigc__p_kv_s[] = { {&_swigt__p_kv_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6014 |
+static swig_cast_info _swigc__p_kva_s[] = { {&_swigt__p_kva_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6015 |
+static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
|
|
6016 |
+static swig_cast_info _swigc__p_profattr_s[] = { {&_swigt__p_profattr_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6017 |
+static swig_cast_info _swigc__p_profstr_s[] = { {&_swigt__p_profstr_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6018 |
+static swig_cast_info _swigc__p_uid_t[] = { {&_swigt__p_uid_t, 0, 0, 0},{0, 0, 0, 0}};
|
|
6019 |
+static swig_cast_info _swigc__p_userattr_s[] = { {&_swigt__p_userattr_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6020 |
+static swig_cast_info _swigc__p_userstr_s[] = { {&_swigt__p_userstr_s, 0, 0, 0},{0, 0, 0, 0}};
|
|
6021 |
+ |
|
6022 |
+static swig_cast_info *swig_cast_initial[] = {
|
|
6023 |
+ _swigc__p___FILE, |
|
6024 |
+ _swigc__p_char, |
|
6025 |
+ _swigc__p_int, |
|
6026 |
+ _swigc__p_kv_s, |
|
6027 |
+ _swigc__p_kva_s, |
|
6028 |
+ _swigc__p_p_char, |
|
6029 |
+ _swigc__p_profattr_s, |
|
6030 |
+ _swigc__p_profstr_s, |
|
6031 |
+ _swigc__p_uid_t, |
|
6032 |
+ _swigc__p_userattr_s, |
|
6033 |
+ _swigc__p_userstr_s, |
|
6034 |
+}; |
|
6035 |
+ |
|
6036 |
+ |
|
6037 |
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ |
|
6038 |
+ |
|
6039 |
+static swig_constant_info swig_constants[] = {
|
|
6040 |
+{0,0,0,0,0,0}
|
|
6041 |
+}; |
|
6042 |
+#ifdef __cplusplus |
|
6043 |
+} |
|
6044 |
+#endif |
|
6045 |
+static swig_variable_info swig_variables[] = {
|
|
6046 |
+{0,0,0,0}
|
|
6047 |
+}; |
|
6048 |
+static swig_command_info swig_commands[] = {
|
|
6049 |
+{"secdbc::profstr_t_name_set", _wrap_profstr_t_name_set},
|
|
6050 |
+{"secdbc::profstr_t_name_get", _wrap_profstr_t_name_get},
|
|
6051 |
+{"secdbc::profstr_t_res1_set", _wrap_profstr_t_res1_set},
|
|
6052 |
+{"secdbc::profstr_t_res1_get", _wrap_profstr_t_res1_get},
|
|
6053 |
+{"secdbc::profstr_t_res2_set", _wrap_profstr_t_res2_set},
|
|
6054 |
+{"secdbc::profstr_t_res2_get", _wrap_profstr_t_res2_get},
|
|
6055 |
+{"secdbc::profstr_t_desc_set", _wrap_profstr_t_desc_set},
|
|
6056 |
+{"secdbc::profstr_t_desc_get", _wrap_profstr_t_desc_get},
|
|
6057 |
+{"secdbc::profstr_t_attr_set", _wrap_profstr_t_attr_set},
|
|
6058 |
+{"secdbc::profstr_t_attr_get", _wrap_profstr_t_attr_get},
|
|
6059 |
+{"secdbc::new_profstr_t", _wrap_new_profstr_t},
|
|
6060 |
+{"secdbc::delete_profstr_t", _wrap_delete_profstr_t},
|
|
6061 |
+{"secdbc::profattr_t_name_set", _wrap_profattr_t_name_set},
|
|
6062 |
+{"secdbc::profattr_t_name_get", _wrap_profattr_t_name_get},
|
|
6063 |
+{"secdbc::profattr_t_res1_set", _wrap_profattr_t_res1_set},
|
|
6064 |
+{"secdbc::profattr_t_res1_get", _wrap_profattr_t_res1_get},
|
|
6065 |
+{"secdbc::profattr_t_res2_set", _wrap_profattr_t_res2_set},
|
|
6066 |
+{"secdbc::profattr_t_res2_get", _wrap_profattr_t_res2_get},
|
|
6067 |
+{"secdbc::profattr_t_desc_set", _wrap_profattr_t_desc_set},
|
|
6068 |
+{"secdbc::profattr_t_desc_get", _wrap_profattr_t_desc_get},
|
|
6069 |
+{"secdbc::profattr_t_attr_set", _wrap_profattr_t_attr_set},
|
|
6070 |
+{"secdbc::profattr_t_attr_get", _wrap_profattr_t_attr_get},
|
|
6071 |
+{"secdbc::new_profattr_t", _wrap_new_profattr_t},
|
|
6072 |
+{"secdbc::delete_profattr_t", _wrap_delete_profattr_t},
|
|
6073 |
+{"secdbc::getprofnam", _wrap_getprofnam},
|
|
6074 |
+{"secdbc::getprofattr", _wrap_getprofattr},
|
|
6075 |
+{"secdbc::getproflist", _wrap_getproflist},
|
|
6076 |
+{"secdbc::setprofattr", _wrap_setprofattr},
|
|
6077 |
+{"secdbc::endprofattr", _wrap_endprofattr},
|
|
6078 |
+{"secdbc::free_profattr", _wrap_free_profattr},
|
|
6079 |
+{"secdbc::free_proflist", _wrap_free_proflist},
|
|
6080 |
+{"secdbc::userstr_t_name_set", _wrap_userstr_t_name_set},
|
|
6081 |
+{"secdbc::userstr_t_name_get", _wrap_userstr_t_name_get},
|
|
6082 |
+{"secdbc::userstr_t_qualifier_set", _wrap_userstr_t_qualifier_set},
|
|
6083 |
+{"secdbc::userstr_t_qualifier_get", _wrap_userstr_t_qualifier_get},
|
|
6084 |
+{"secdbc::userstr_t_res1_set", _wrap_userstr_t_res1_set},
|
|
6085 |
+{"secdbc::userstr_t_res1_get", _wrap_userstr_t_res1_get},
|
|
6086 |
+{"secdbc::userstr_t_res2_set", _wrap_userstr_t_res2_set},
|
|
6087 |
+{"secdbc::userstr_t_res2_get", _wrap_userstr_t_res2_get},
|
|
6088 |
+{"secdbc::userstr_t_attr_set", _wrap_userstr_t_attr_set},
|
|
6089 |
+{"secdbc::userstr_t_attr_get", _wrap_userstr_t_attr_get},
|
|
6090 |
+{"secdbc::new_userstr_t", _wrap_new_userstr_t},
|
|
6091 |
+{"secdbc::delete_userstr_t", _wrap_delete_userstr_t},
|
|
6092 |
+{"secdbc::userattr_t_name_set", _wrap_userattr_t_name_set},
|
|
6093 |
+{"secdbc::userattr_t_name_get", _wrap_userattr_t_name_get},
|
|
6094 |
+{"secdbc::userattr_t_qualifier_set", _wrap_userattr_t_qualifier_set},
|
|
6095 |
+{"secdbc::userattr_t_qualifier_get", _wrap_userattr_t_qualifier_get},
|
|
6096 |
+{"secdbc::userattr_t_res1_set", _wrap_userattr_t_res1_set},
|
|
6097 |
+{"secdbc::userattr_t_res1_get", _wrap_userattr_t_res1_get},
|
|
6098 |
+{"secdbc::userattr_t_res2_set", _wrap_userattr_t_res2_set},
|
|
6099 |
+{"secdbc::userattr_t_res2_get", _wrap_userattr_t_res2_get},
|
|
6100 |
+{"secdbc::userattr_t_attr_set", _wrap_userattr_t_attr_set},
|
|
6101 |
+{"secdbc::userattr_t_attr_get", _wrap_userattr_t_attr_get},
|
|
6102 |
+{"secdbc::new_userattr_t", _wrap_new_userattr_t},
|
|
6103 |
+{"secdbc::delete_userattr_t", _wrap_delete_userattr_t},
|
|
6104 |
+{"secdbc::getusernam", _wrap_getusernam},
|
|
6105 |
+{"secdbc::getuseruid", _wrap_getuseruid},
|
|
6106 |
+{"secdbc::getuserattr", _wrap_getuserattr},
|
|
6107 |
+{"secdbc::fgetuserattr", _wrap_fgetuserattr},
|
|
6108 |
+{"secdbc::setuserattr", _wrap_setuserattr},
|
|
6109 |
+{"secdbc::enduserattr", _wrap_enduserattr},
|
|
6110 |
+{"secdbc::free_userattr", _wrap_free_userattr},
|
|
6111 |
+{"secdbc::kv_t_key_set", _wrap_kv_t_key_set},
|
|
6112 |
+{"secdbc::kv_t_key_get", _wrap_kv_t_key_get},
|
|
6113 |
+{"secdbc::kv_t_value_set", _wrap_kv_t_value_set},
|
|
6114 |
+{"secdbc::kv_t_value_get", _wrap_kv_t_value_get},
|
|
6115 |
+{"secdbc::new_kv_t", _wrap_new_kv_t},
|
|
6116 |
+{"secdbc::delete_kv_t", _wrap_delete_kv_t},
|
|
6117 |
+{"secdbc::kva_t_length_set", _wrap_kva_t_length_set},
|
|
6118 |
+{"secdbc::kva_t_length_get", _wrap_kva_t_length_get},
|
|
6119 |
+{"secdbc::kva_t_data_set", _wrap_kva_t_data_set},
|
|
6120 |
+{"secdbc::kva_t_data_get", _wrap_kva_t_data_get},
|
|
6121 |
+{"secdbc::new_kva_t", _wrap_new_kva_t},
|
|
6122 |
+{"secdbc::delete_kva_t", _wrap_delete_kva_t},
|
|
6123 |
+{"secdbc::kva_match", _wrap_kva_match},
|
|
6124 |
+{"secdbc::_auth_match", _wrap__auth_match},
|
|
6125 |
+{"secdbc::_argv_to_csl", _wrap__argv_to_csl},
|
|
6126 |
+{"secdbc::_csl_to_argv", _wrap__csl_to_argv},
|
|
6127 |
+{"secdbc::_do_unescape", _wrap__do_unescape},
|
|
6128 |
+{"secdbc::_free_argv", _wrap__free_argv},
|
|
6129 |
+{"secdbc::_insert2kva", _wrap__insert2kva},
|
|
6130 |
+{"secdbc::_kva2str", _wrap__kva2str},
|
|
6131 |
+{"secdbc::_kva_dup", _wrap__kva_dup},
|
|
6132 |
+{"secdbc::_kva_free", _wrap__kva_free},
|
|
6133 |
+{"secdbc::_new_kva", _wrap__new_kva},
|
|
6134 |
+{"secdbc::_str2kva", _wrap__str2kva},
|
|
6135 |
+{0,0}
|
|
6136 |
+}; |
|
6137 |
+/* ----------------------------------------------------------------------------- |
|
6138 |
+ * Type initialization: |
|
6139 |
+ * This problem is tough by the requirement that no dynamic |
|
6140 |
+ * memory is used. Also, since swig_type_info structures store pointers to |
|
6141 |
+ * swig_cast_info structures and swig_cast_info structures store pointers back |
|
6142 |
+ * to swig_type_info structures, we need some lookup code at initialization. |
|
6143 |
+ * The idea is that swig generates all the structures that are needed. |
|
6144 |
+ * The runtime then collects these partially filled structures. |
|
6145 |
+ * The SWIG_InitializeModule function takes these initial arrays out of |
|
6146 |
+ * swig_module, and does all the lookup, filling in the swig_module.types |
|
6147 |
+ * array with the correct data and linking the correct swig_cast_info |
|
6148 |
+ * structures together. |
|
6149 |
+ * |
|
6150 |
+ * The generated swig_type_info structures are assigned staticly to an initial |
|
6151 |
+ * array. We just loop through that array, and handle each type individually. |
|
6152 |
+ * First we lookup if this type has been already loaded, and if so, use the |
|
6153 |
+ * loaded structure instead of the generated one. Then we have to fill in the |
|
6154 |
+ * cast linked list. The cast data is initially stored in something like a |
|
6155 |
+ * two-dimensional array. Each row corresponds to a type (there are the same |
|
6156 |
+ * number of rows as there are in the swig_type_initial array). Each entry in |
|
6157 |
+ * a column is one of the swig_cast_info structures for that type. |
|
6158 |
+ * The cast_initial array is actually an array of arrays, because each row has |
|
6159 |
+ * a variable number of columns. So to actually build the cast linked list, |
|
6160 |
+ * we find the array of casts associated with the type, and loop through it |
|
6161 |
+ * adding the casts to the list. The one last trick we need to do is making |
|
6162 |
+ * sure the type pointer in the swig_cast_info struct is correct. |
|
6163 |
+ * |
|
6164 |
+ * First off, we lookup the cast->type name to see if it is already loaded. |
|
6165 |
+ * There are three cases to handle: |
|
6166 |
+ * 1) If the cast->type has already been loaded AND the type we are adding |
|
6167 |
+ * casting info to has not been loaded (it is in this module), THEN we |
|
6168 |
+ * replace the cast->type pointer with the type pointer that has already |
|
6169 |
+ * been loaded. |
|
6170 |
+ * 2) If BOTH types (the one we are adding casting info to, and the |
|
6171 |
+ * cast->type) are loaded, THEN the cast info has already been loaded by |
|
6172 |
+ * the previous module so we just ignore it. |
|
6173 |
+ * 3) Finally, if cast->type has not already been loaded, then we add that |
|
6174 |
+ * swig_cast_info to the linked list (because the cast->type) pointer will |
|
6175 |
+ * be correct. |
|
6176 |
+ * ----------------------------------------------------------------------------- */ |
|
6177 |
+ |
|
6178 |
+#ifdef __cplusplus |
|
6179 |
+extern "C" {
|
|
6180 |
+#if 0 |
|
6181 |
+} /* c-mode */ |
|
6182 |
+#endif |
|
6183 |
+#endif |
|
6184 |
+ |
|
6185 |
+#if 0 |
|
6186 |
+#define SWIGRUNTIME_DEBUG |
|
6187 |
+#endif |
|
6188 |
+ |
|
6189 |
+ |
|
6190 |
+SWIGRUNTIME void |
|
6191 |
+SWIG_InitializeModule(void *clientdata) {
|
|
6192 |
+ size_t i; |
|
6193 |
+ swig_module_info *module_head, *iter; |
|
6194 |
+ int found, init; |
|
6195 |
+ |
|
6196 |
+ clientdata = clientdata; |
|
6197 |
+ |
|
6198 |
+ /* check to see if the circular list has been setup, if not, set it up */ |
|
6199 |
+ if (swig_module.next==0) {
|
|
6200 |
+ /* Initialize the swig_module */ |
|
6201 |
+ swig_module.type_initial = swig_type_initial; |
|
6202 |
+ swig_module.cast_initial = swig_cast_initial; |
|
6203 |
+ swig_module.next = &swig_module; |
|
6204 |
+ init = 1; |
|
6205 |
+ } else {
|
|
6206 |
+ init = 0; |
|
6207 |
+ } |
|
6208 |
+ |
|
6209 |
+ /* Try and load any already created modules */ |
|
6210 |
+ module_head = SWIG_GetModule(clientdata); |
|
6211 |
+ if (!module_head) {
|
|
6212 |
+ /* This is the first module loaded for this interpreter */ |
|
6213 |
+ /* so set the swig module into the interpreter */ |
|
6214 |
+ SWIG_SetModule(clientdata, &swig_module); |
|
6215 |
+ module_head = &swig_module; |
|
6216 |
+ } else {
|
|
6217 |
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */ |
|
6218 |
+ found=0; |
|
6219 |
+ iter=module_head; |
|
6220 |
+ do {
|
|
6221 |
+ if (iter==&swig_module) {
|
|
6222 |
+ found=1; |
|
6223 |
+ break; |
|
6224 |
+ } |
|
6225 |
+ iter=iter->next; |
|
6226 |
+ } while (iter!= module_head); |
|
6227 |
+ |
|
6228 |
+ /* if the is found in the list, then all is done and we may leave */ |
|
6229 |
+ if (found) return; |
|
6230 |
+ /* otherwise we must add out module into the list */ |
|
6231 |
+ swig_module.next = module_head->next; |
|
6232 |
+ module_head->next = &swig_module; |
|
6233 |
+ } |
|
6234 |
+ |
|
6235 |
+ /* When multiple interpeters are used, a module could have already been initialized in |
|
6236 |
+ a different interpreter, but not yet have a pointer in this interpreter. |
|
6237 |
+ In this case, we do not want to continue adding types... everything should be |
|
6238 |
+ set up already */ |
|
6239 |
+ if (init == 0) return; |
|
6240 |
+ |
|
6241 |
+ /* Now work on filling in swig_module.types */ |
|
6242 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6243 |
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
|
|
6244 |
+#endif |
|
6245 |
+ for (i = 0; i < swig_module.size; ++i) {
|
|
6246 |
+ swig_type_info *type = 0; |
|
6247 |
+ swig_type_info *ret; |
|
6248 |
+ swig_cast_info *cast; |
|
6249 |
+ |
|
6250 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6251 |
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
|
6252 |
+#endif |
|
6253 |
+ |
|
6254 |
+ /* if there is another module already loaded */ |
|
6255 |
+ if (swig_module.next != &swig_module) {
|
|
6256 |
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); |
|
6257 |
+ } |
|
6258 |
+ if (type) {
|
|
6259 |
+ /* Overwrite clientdata field */ |
|
6260 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6261 |
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
|
|
6262 |
+#endif |
|
6263 |
+ if (swig_module.type_initial[i]->clientdata) {
|
|
6264 |
+ type->clientdata = swig_module.type_initial[i]->clientdata; |
|
6265 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6266 |
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
|
|
6267 |
+#endif |
|
6268 |
+ } |
|
6269 |
+ } else {
|
|
6270 |
+ type = swig_module.type_initial[i]; |
|
6271 |
+ } |
|
6272 |
+ |
|
6273 |
+ /* Insert casting types */ |
|
6274 |
+ cast = swig_module.cast_initial[i]; |
|
6275 |
+ while (cast->type) {
|
|
6276 |
+ /* Don't need to add information already in the list */ |
|
6277 |
+ ret = 0; |
|
6278 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6279 |
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
|
|
6280 |
+#endif |
|
6281 |
+ if (swig_module.next != &swig_module) {
|
|
6282 |
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); |
|
6283 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6284 |
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
|
|
6285 |
+#endif |
|
6286 |
+ } |
|
6287 |
+ if (ret) {
|
|
6288 |
+ if (type == swig_module.type_initial[i]) {
|
|
6289 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6290 |
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
|
|
6291 |
+#endif |
|
6292 |
+ cast->type = ret; |
|
6293 |
+ ret = 0; |
|
6294 |
+ } else {
|
|
6295 |
+ /* Check for casting already in the list */ |
|
6296 |
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); |
|
6297 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6298 |
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
|
|
6299 |
+#endif |
|
6300 |
+ if (!ocast) ret = 0; |
|
6301 |
+ } |
|
6302 |
+ } |
|
6303 |
+ |
|
6304 |
+ if (!ret) {
|
|
6305 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6306 |
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
|
|
6307 |
+#endif |
|
6308 |
+ if (type->cast) {
|
|
6309 |
+ type->cast->prev = cast; |
|
6310 |
+ cast->next = type->cast; |
|
6311 |
+ } |
|
6312 |
+ type->cast = cast; |
|
6313 |
+ } |
|
6314 |
+ cast++; |
|
6315 |
+ } |
|
6316 |
+ /* Set entry in modules->types array equal to the type */ |
|
6317 |
+ swig_module.types[i] = type; |
|
6318 |
+ } |
|
6319 |
+ swig_module.types[i] = 0; |
|
6320 |
+ |
|
6321 |
+#ifdef SWIGRUNTIME_DEBUG |
|
6322 |
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
|
|
6323 |
+ for (i = 0; i < swig_module.size; ++i) {
|
|
6324 |
+ int j = 0; |
|
6325 |
+ swig_cast_info *cast = swig_module.cast_initial[i]; |
|
6326 |
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
|
6327 |
+ while (cast->type) {
|
|
6328 |
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
|
|
6329 |
+ cast++; |
|
6330 |
+ ++j; |
|
6331 |
+ } |
|
6332 |
+ printf("---- Total casts: %d\n",j);
|
|
6333 |
+ } |
|
6334 |
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
|
|
6335 |
+#endif |
|
6336 |
+} |
|
6337 |
+ |
|
6338 |
+/* This function will propagate the clientdata field of type to |
|
6339 |
+* any new swig_type_info structures that have been added into the list |
|
6340 |
+* of equivalent types. It is like calling |
|
6341 |
+* SWIG_TypeClientData(type, clientdata) a second time. |
|
6342 |
+*/ |
|
6343 |
+SWIGRUNTIME void |
|
6344 |
+SWIG_PropagateClientData(void) {
|
|
6345 |
+ size_t i; |
|
6346 |
+ swig_cast_info *equiv; |
|
6347 |
+ static int init_run = 0; |
|
6348 |
+ |
|
6349 |
+ if (init_run) return; |
|
6350 |
+ init_run = 1; |
|
6351 |
+ |
|
6352 |
+ for (i = 0; i < swig_module.size; i++) {
|
|
6353 |
+ if (swig_module.types[i]->clientdata) {
|
|
6354 |
+ equiv = swig_module.types[i]->cast; |
|
6355 |
+ while (equiv) {
|
|
6356 |
+ if (!equiv->converter) {
|
|
6357 |
+ if (equiv->type && !equiv->type->clientdata) |
|
6358 |
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); |
|
6359 |
+ } |
|
6360 |
+ equiv = equiv->next; |
|
6361 |
+ } |
|
6362 |
+ } |
|
6363 |
+ } |
|
6364 |
+} |
|
6365 |
+ |
|
6366 |
+#ifdef __cplusplus |
|
6367 |
+#if 0 |
|
6368 |
+{
|
|
6369 |
+ /* c-mode */ |
|
6370 |
+#endif |
|
6371 |
+} |
|
6372 |
+#endif |
|
6373 |
+ |
|
6374 |
+ |
|
6375 |
+ |
|
6376 |
+#ifdef __cplusplus |
|
6377 |
+extern "C" |
|
6378 |
+#endif |
|
6379 |
+ |
|
6380 |
+XS(SWIG_init) {
|
|
6381 |
+ dXSARGS; |
|
6382 |
+ int i; |
|
6383 |
+ |
|
6384 |
+ SWIG_InitializeModule(0); |
|
6385 |
+ |
|
6386 |
+ /* Install commands */ |
|
6387 |
+ for (i = 0; swig_commands[i].name; i++) {
|
|
6388 |
+ newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__); |
|
6389 |
+ } |
|
6390 |
+ |
|
6391 |
+ /* Install variables */ |
|
6392 |
+ for (i = 0; swig_variables[i].name; i++) {
|
|
6393 |
+ SV *sv; |
|
6394 |
+ sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI); |
|
6395 |
+ if (swig_variables[i].type) {
|
|
6396 |
+ SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0); |
|
6397 |
+ } else {
|
|
6398 |
+ sv_setiv(sv,(IV) 0); |
|
6399 |
+ } |
|
6400 |
+ swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); |
|
6401 |
+ } |
|
6402 |
+ |
|
6403 |
+ /* Install constant */ |
|
6404 |
+ for (i = 0; swig_constants[i].type; i++) {
|
|
6405 |
+ SV *sv; |
|
6406 |
+ sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI); |
|
6407 |
+ switch(swig_constants[i].type) {
|
|
6408 |
+ case SWIG_INT: |
|
6409 |
+ sv_setiv(sv, (IV) swig_constants[i].lvalue); |
|
6410 |
+ break; |
|
6411 |
+ case SWIG_FLOAT: |
|
6412 |
+ sv_setnv(sv, (double) swig_constants[i].dvalue); |
|
6413 |
+ break; |
|
6414 |
+ case SWIG_STRING: |
|
6415 |
+ sv_setpv(sv, (char *) swig_constants[i].pvalue); |
|
6416 |
+ break; |
|
6417 |
+ case SWIG_POINTER: |
|
6418 |
+ SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0); |
|
6419 |
+ break; |
|
6420 |
+ case SWIG_BINARY: |
|
6421 |
+ SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype)); |
|
6422 |
+ break; |
|
6423 |
+ default: |
|
6424 |
+ break; |
|
6425 |
+ } |
|
6426 |
+ SvREADONLY_on(sv); |
|
6427 |
+ } |
|
6428 |
+ |
|
6429 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6430 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_FILENAME", TRUE | 0x2 | GV_ADDMULTI); |
|
6431 |
+ sv_setsv(sv, SWIG_FromCharPtr("/etc/security/prof_attr"));
|
|
6432 |
+ SvREADONLY_on(sv); |
|
6433 |
+ } while(0) /*@SWIG@*/; |
|
6434 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6435 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_DB_NAME", TRUE | 0x2 | GV_ADDMULTI); |
|
6436 |
+ sv_setsv(sv, SWIG_FromCharPtr("prof_attr.org_dir"));
|
|
6437 |
+ SvREADONLY_on(sv); |
|
6438 |
+ } while(0) /*@SWIG@*/; |
|
6439 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6440 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_DB_NCOL", TRUE | 0x2 | GV_ADDMULTI); |
|
6441 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(5))); |
|
6442 |
+ SvREADONLY_on(sv); |
|
6443 |
+ } while(0) /*@SWIG@*/; |
|
6444 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6445 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_DB_NKEYCOL", TRUE | 0x2 | GV_ADDMULTI); |
|
6446 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(1))); |
|
6447 |
+ SvREADONLY_on(sv); |
|
6448 |
+ } while(0) /*@SWIG@*/; |
|
6449 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6450 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_DB_TBLT", TRUE | 0x2 | GV_ADDMULTI); |
|
6451 |
+ sv_setsv(sv, SWIG_FromCharPtr("prof_attr_tbl"));
|
|
6452 |
+ SvREADONLY_on(sv); |
|
6453 |
+ } while(0) /*@SWIG@*/; |
|
6454 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6455 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_NAME_DEFAULT_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6456 |
+ sv_setsv(sv, SWIG_FromCharPtr("nobody"));
|
|
6457 |
+ SvREADONLY_on(sv); |
|
6458 |
+ } while(0) /*@SWIG@*/; |
|
6459 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6460 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_COL0_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6461 |
+ sv_setsv(sv, SWIG_FromCharPtr("name"));
|
|
6462 |
+ SvREADONLY_on(sv); |
|
6463 |
+ } while(0) /*@SWIG@*/; |
|
6464 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6465 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_COL1_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6466 |
+ sv_setsv(sv, SWIG_FromCharPtr("res1"));
|
|
6467 |
+ SvREADONLY_on(sv); |
|
6468 |
+ } while(0) /*@SWIG@*/; |
|
6469 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6470 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_COL2_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6471 |
+ sv_setsv(sv, SWIG_FromCharPtr("res2"));
|
|
6472 |
+ SvREADONLY_on(sv); |
|
6473 |
+ } while(0) /*@SWIG@*/; |
|
6474 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6475 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_COL3_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6476 |
+ sv_setsv(sv, SWIG_FromCharPtr("desc"));
|
|
6477 |
+ SvREADONLY_on(sv); |
|
6478 |
+ } while(0) /*@SWIG@*/; |
|
6479 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6480 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_COL4_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6481 |
+ sv_setsv(sv, SWIG_FromCharPtr("attr"));
|
|
6482 |
+ SvREADONLY_on(sv); |
|
6483 |
+ } while(0) /*@SWIG@*/; |
|
6484 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6485 |
+ SV *sv = get_sv((char*) SWIG_prefix "DEF_PROF", TRUE | 0x2 | GV_ADDMULTI); |
|
6486 |
+ sv_setsv(sv, SWIG_FromCharPtr("PROFS_GRANTED="));
|
|
6487 |
+ SvREADONLY_on(sv); |
|
6488 |
+ } while(0) /*@SWIG@*/; |
|
6489 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6490 |
+ SV *sv = get_sv((char*) SWIG_prefix "DEF_CONSUSER", TRUE | 0x2 | GV_ADDMULTI); |
|
6491 |
+ sv_setsv(sv, SWIG_FromCharPtr("CONSOLE_USER="));
|
|
6492 |
+ SvREADONLY_on(sv); |
|
6493 |
+ } while(0) /*@SWIG@*/; |
|
6494 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6495 |
+ SV *sv = get_sv((char*) SWIG_prefix "MAXPROFS", TRUE | 0x2 | GV_ADDMULTI); |
|
6496 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(4096))); |
|
6497 |
+ SvREADONLY_on(sv); |
|
6498 |
+ } while(0) /*@SWIG@*/; |
|
6499 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6500 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_KEYCOL0", TRUE | 0x2 | GV_ADDMULTI); |
|
6501 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0))); |
|
6502 |
+ SvREADONLY_on(sv); |
|
6503 |
+ } while(0) /*@SWIG@*/; |
|
6504 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6505 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_AUTHS_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6506 |
+ sv_setsv(sv, SWIG_FromCharPtr("auths"));
|
|
6507 |
+ SvREADONLY_on(sv); |
|
6508 |
+ } while(0) /*@SWIG@*/; |
|
6509 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6510 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_PROFS_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6511 |
+ sv_setsv(sv, SWIG_FromCharPtr("profiles"));
|
|
6512 |
+ SvREADONLY_on(sv); |
|
6513 |
+ } while(0) /*@SWIG@*/; |
|
6514 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6515 |
+ SV *sv = get_sv((char*) SWIG_prefix "PROFATTR_PRIVS_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6516 |
+ sv_setsv(sv, SWIG_FromCharPtr("privs"));
|
|
6517 |
+ SvREADONLY_on(sv); |
|
6518 |
+ } while(0) /*@SWIG@*/; |
|
6519 |
+ SWIG_TypeClientData(SWIGTYPE_p_profstr_s, (void*) "secdb::profstr_t"); |
|
6520 |
+ SWIG_TypeClientData(SWIGTYPE_p_profattr_s, (void*) "secdb::profattr_t"); |
|
6521 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6522 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_FILENAME", TRUE | 0x2 | GV_ADDMULTI); |
|
6523 |
+ sv_setsv(sv, SWIG_FromCharPtr("/etc/user_attr"));
|
|
6524 |
+ SvREADONLY_on(sv); |
|
6525 |
+ } while(0) /*@SWIG@*/; |
|
6526 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6527 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DB_NAME", TRUE | 0x2 | GV_ADDMULTI); |
|
6528 |
+ sv_setsv(sv, SWIG_FromCharPtr("user_attr.org_dir"));
|
|
6529 |
+ SvREADONLY_on(sv); |
|
6530 |
+ } while(0) /*@SWIG@*/; |
|
6531 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6532 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DB_NCOL", TRUE | 0x2 | GV_ADDMULTI); |
|
6533 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(5))); |
|
6534 |
+ SvREADONLY_on(sv); |
|
6535 |
+ } while(0) /*@SWIG@*/; |
|
6536 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6537 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DB_NKEYCOL", TRUE | 0x2 | GV_ADDMULTI); |
|
6538 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(2))); |
|
6539 |
+ SvREADONLY_on(sv); |
|
6540 |
+ } while(0) /*@SWIG@*/; |
|
6541 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6542 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DB_TBL", TRUE | 0x2 | GV_ADDMULTI); |
|
6543 |
+ sv_setsv(sv, SWIG_FromCharPtr("user_attr_tbl"));
|
|
6544 |
+ SvREADONLY_on(sv); |
|
6545 |
+ } while(0) /*@SWIG@*/; |
|
6546 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6547 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_NAME_DEFAULT_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6548 |
+ sv_setsv(sv, SWIG_FromCharPtr("nobody"));
|
|
6549 |
+ SvREADONLY_on(sv); |
|
6550 |
+ } while(0) /*@SWIG@*/; |
|
6551 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6552 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_COL0_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6553 |
+ sv_setsv(sv, SWIG_FromCharPtr("name"));
|
|
6554 |
+ SvREADONLY_on(sv); |
|
6555 |
+ } while(0) /*@SWIG@*/; |
|
6556 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6557 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_COL1_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6558 |
+ sv_setsv(sv, SWIG_FromCharPtr("qualifier"));
|
|
6559 |
+ SvREADONLY_on(sv); |
|
6560 |
+ } while(0) /*@SWIG@*/; |
|
6561 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6562 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_COL2_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6563 |
+ sv_setsv(sv, SWIG_FromCharPtr("res1"));
|
|
6564 |
+ SvREADONLY_on(sv); |
|
6565 |
+ } while(0) /*@SWIG@*/; |
|
6566 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6567 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_COL3_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6568 |
+ sv_setsv(sv, SWIG_FromCharPtr("res2"));
|
|
6569 |
+ SvREADONLY_on(sv); |
|
6570 |
+ } while(0) /*@SWIG@*/; |
|
6571 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6572 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_COL4_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6573 |
+ sv_setsv(sv, SWIG_FromCharPtr("attr"));
|
|
6574 |
+ SvREADONLY_on(sv); |
|
6575 |
+ } while(0) /*@SWIG@*/; |
|
6576 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6577 |
+ SV *sv = get_sv((char*) SWIG_prefix "DEF_LIMITPRIV", TRUE | 0x2 | GV_ADDMULTI); |
|
6578 |
+ sv_setsv(sv, SWIG_FromCharPtr("PRIV_LIMIT="));
|
|
6579 |
+ SvREADONLY_on(sv); |
|
6580 |
+ } while(0) /*@SWIG@*/; |
|
6581 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6582 |
+ SV *sv = get_sv((char*) SWIG_prefix "DEF_DFLTPRIV", TRUE | 0x2 | GV_ADDMULTI); |
|
6583 |
+ sv_setsv(sv, SWIG_FromCharPtr("PRIV_DEFAULT="));
|
|
6584 |
+ SvREADONLY_on(sv); |
|
6585 |
+ } while(0) /*@SWIG@*/; |
|
6586 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6587 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_KEYCOL0", TRUE | 0x2 | GV_ADDMULTI); |
|
6588 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0))); |
|
6589 |
+ SvREADONLY_on(sv); |
|
6590 |
+ } while(0) /*@SWIG@*/; |
|
6591 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6592 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_KEYCOL1", TRUE | 0x2 | GV_ADDMULTI); |
|
6593 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(1))); |
|
6594 |
+ SvREADONLY_on(sv); |
|
6595 |
+ } while(0) /*@SWIG@*/; |
|
6596 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6597 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6598 |
+ sv_setsv(sv, SWIG_FromCharPtr("lock"));
|
|
6599 |
+ SvREADONLY_on(sv); |
|
6600 |
+ } while(0) /*@SWIG@*/; |
|
6601 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6602 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_LOCKED_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6603 |
+ sv_setsv(sv, SWIG_FromCharPtr("locked"));
|
|
6604 |
+ SvREADONLY_on(sv); |
|
6605 |
+ } while(0) /*@SWIG@*/; |
|
6606 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6607 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_OPEN_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6608 |
+ sv_setsv(sv, SWIG_FromCharPtr("open"));
|
|
6609 |
+ SvREADONLY_on(sv); |
|
6610 |
+ } while(0) /*@SWIG@*/; |
|
6611 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6612 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_FIXED_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6613 |
+ sv_setsv(sv, SWIG_FromCharPtr("fixed"));
|
|
6614 |
+ SvREADONLY_on(sv); |
|
6615 |
+ } while(0) /*@SWIG@*/; |
|
6616 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6617 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_GEN_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6618 |
+ sv_setsv(sv, SWIG_FromCharPtr("gen"));
|
|
6619 |
+ SvREADONLY_on(sv); |
|
6620 |
+ } while(0) /*@SWIG@*/; |
|
6621 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6622 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_GEN_AUTOMATIC_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6623 |
+ sv_setsv(sv, SWIG_FromCharPtr("automatic"));
|
|
6624 |
+ SvREADONLY_on(sv); |
|
6625 |
+ } while(0) /*@SWIG@*/; |
|
6626 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6627 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_GEN_MANUAL_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6628 |
+ sv_setsv(sv, SWIG_FromCharPtr("manual"));
|
|
6629 |
+ SvREADONLY_on(sv); |
|
6630 |
+ } while(0) /*@SWIG@*/; |
|
6631 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6632 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_GEN_SYSDEF_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6633 |
+ sv_setsv(sv, SWIG_FromCharPtr("sysdef"));
|
|
6634 |
+ SvREADONLY_on(sv); |
|
6635 |
+ } while(0) /*@SWIG@*/; |
|
6636 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6637 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_PROFILES_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6638 |
+ sv_setsv(sv, SWIG_FromCharPtr("profiles"));
|
|
6639 |
+ SvREADONLY_on(sv); |
|
6640 |
+ } while(0) /*@SWIG@*/; |
|
6641 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6642 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_PROFILES_NONE_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6643 |
+ sv_setsv(sv, SWIG_FromCharPtr("none"));
|
|
6644 |
+ SvREADONLY_on(sv); |
|
6645 |
+ } while(0) /*@SWIG@*/; |
|
6646 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6647 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_ROLES_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6648 |
+ sv_setsv(sv, SWIG_FromCharPtr("roles"));
|
|
6649 |
+ SvREADONLY_on(sv); |
|
6650 |
+ } while(0) /*@SWIG@*/; |
|
6651 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6652 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_ROLES_NONE_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6653 |
+ sv_setsv(sv, SWIG_FromCharPtr("none"));
|
|
6654 |
+ SvREADONLY_on(sv); |
|
6655 |
+ } while(0) /*@SWIG@*/; |
|
6656 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6657 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DEFAULTPROJ_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6658 |
+ sv_setsv(sv, SWIG_FromCharPtr("project"));
|
|
6659 |
+ SvREADONLY_on(sv); |
|
6660 |
+ } while(0) /*@SWIG@*/; |
|
6661 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6662 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_IDLETIME_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6663 |
+ sv_setsv(sv, SWIG_FromCharPtr("idletime"));
|
|
6664 |
+ SvREADONLY_on(sv); |
|
6665 |
+ } while(0) /*@SWIG@*/; |
|
6666 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6667 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_IDLECMD_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6668 |
+ sv_setsv(sv, SWIG_FromCharPtr("idlecmd"));
|
|
6669 |
+ SvREADONLY_on(sv); |
|
6670 |
+ } while(0) /*@SWIG@*/; |
|
6671 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6672 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_IDLECMD_LOCK_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6673 |
+ sv_setsv(sv, SWIG_FromCharPtr("lock"));
|
|
6674 |
+ SvREADONLY_on(sv); |
|
6675 |
+ } while(0) /*@SWIG@*/; |
|
6676 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6677 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_IDLECMD_LOGOUT_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6678 |
+ sv_setsv(sv, SWIG_FromCharPtr("logout"));
|
|
6679 |
+ SvREADONLY_on(sv); |
|
6680 |
+ } while(0) /*@SWIG@*/; |
|
6681 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6682 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_TYPE_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6683 |
+ sv_setsv(sv, SWIG_FromCharPtr("type"));
|
|
6684 |
+ SvREADONLY_on(sv); |
|
6685 |
+ } while(0) /*@SWIG@*/; |
|
6686 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6687 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_TYPE_NORMAL_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6688 |
+ sv_setsv(sv, SWIG_FromCharPtr("normal"));
|
|
6689 |
+ SvREADONLY_on(sv); |
|
6690 |
+ } while(0) /*@SWIG@*/; |
|
6691 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6692 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_TYPE_ADMIN_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6693 |
+ sv_setsv(sv, SWIG_FromCharPtr("admin"));
|
|
6694 |
+ SvREADONLY_on(sv); |
|
6695 |
+ } while(0) /*@SWIG@*/; |
|
6696 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6697 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_TYPE_NONADMIN_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6698 |
+ sv_setsv(sv, SWIG_FromCharPtr("role"));
|
|
6699 |
+ SvREADONLY_on(sv); |
|
6700 |
+ } while(0) /*@SWIG@*/; |
|
6701 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6702 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_AUTHS_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6703 |
+ sv_setsv(sv, SWIG_FromCharPtr("auths"));
|
|
6704 |
+ SvREADONLY_on(sv); |
|
6705 |
+ } while(0) /*@SWIG@*/; |
|
6706 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6707 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LIMPRIV_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6708 |
+ sv_setsv(sv, SWIG_FromCharPtr("limitpriv"));
|
|
6709 |
+ SvREADONLY_on(sv); |
|
6710 |
+ } while(0) /*@SWIG@*/; |
|
6711 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6712 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_DFLTPRIV_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6713 |
+ sv_setsv(sv, SWIG_FromCharPtr("defaultpriv"));
|
|
6714 |
+ SvREADONLY_on(sv); |
|
6715 |
+ } while(0) /*@SWIG@*/; |
|
6716 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6717 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_AFTER_RETRIES_KW", TRUE | 0x2 | GV_ADDMULTI); |
|
6718 |
+ sv_setsv(sv, SWIG_FromCharPtr("lock_after_retries"));
|
|
6719 |
+ SvREADONLY_on(sv); |
|
6720 |
+ } while(0) /*@SWIG@*/; |
|
6721 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6722 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_CLEARANCE", TRUE | 0x2 | GV_ADDMULTI); |
|
6723 |
+ sv_setsv(sv, SWIG_FromCharPtr("clearance"));
|
|
6724 |
+ SvREADONLY_on(sv); |
|
6725 |
+ } while(0) /*@SWIG@*/; |
|
6726 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6727 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELVIEW", TRUE | 0x2 | GV_ADDMULTI); |
|
6728 |
+ sv_setsv(sv, SWIG_FromCharPtr("labelview"));
|
|
6729 |
+ SvREADONLY_on(sv); |
|
6730 |
+ } while(0) /*@SWIG@*/; |
|
6731 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6732 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELVIEW_EXTERNAL", TRUE | 0x2 | GV_ADDMULTI); |
|
6733 |
+ sv_setsv(sv, SWIG_FromCharPtr("external"));
|
|
6734 |
+ SvREADONLY_on(sv); |
|
6735 |
+ } while(0) /*@SWIG@*/; |
|
6736 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6737 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELVIEW_HIDESL", TRUE | 0x2 | GV_ADDMULTI); |
|
6738 |
+ sv_setsv(sv, SWIG_FromCharPtr("hidesl"));
|
|
6739 |
+ SvREADONLY_on(sv); |
|
6740 |
+ } while(0) /*@SWIG@*/; |
|
6741 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6742 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_HIDESL", TRUE | 0x2 | GV_ADDMULTI); |
|
6743 |
+ sv_setsv(sv, SWIG_FromCharPtr("hidesl"));
|
|
6744 |
+ SvREADONLY_on(sv); |
|
6745 |
+ } while(0) /*@SWIG@*/; |
|
6746 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6747 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELVIEW_INTERNAL", TRUE | 0x2 | GV_ADDMULTI); |
|
6748 |
+ sv_setsv(sv, SWIG_FromCharPtr("internal"));
|
|
6749 |
+ SvREADONLY_on(sv); |
|
6750 |
+ } while(0) /*@SWIG@*/; |
|
6751 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6752 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELVIEW_SHOWSL", TRUE | 0x2 | GV_ADDMULTI); |
|
6753 |
+ sv_setsv(sv, SWIG_FromCharPtr("showsl"));
|
|
6754 |
+ SvREADONLY_on(sv); |
|
6755 |
+ } while(0) /*@SWIG@*/; |
|
6756 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6757 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LABELTRANS", TRUE | 0x2 | GV_ADDMULTI); |
|
6758 |
+ sv_setsv(sv, SWIG_FromCharPtr("labeltrans"));
|
|
6759 |
+ SvREADONLY_on(sv); |
|
6760 |
+ } while(0) /*@SWIG@*/; |
|
6761 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6762 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_NO", TRUE | 0x2 | GV_ADDMULTI); |
|
6763 |
+ sv_setsv(sv, SWIG_FromCharPtr("no"));
|
|
6764 |
+ SvREADONLY_on(sv); |
|
6765 |
+ } while(0) /*@SWIG@*/; |
|
6766 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6767 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_LOCK_YES", TRUE | 0x2 | GV_ADDMULTI); |
|
6768 |
+ sv_setsv(sv, SWIG_FromCharPtr("yes"));
|
|
6769 |
+ SvREADONLY_on(sv); |
|
6770 |
+ } while(0) /*@SWIG@*/; |
|
6771 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6772 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_MINLABEL", TRUE | 0x2 | GV_ADDMULTI); |
|
6773 |
+ sv_setsv(sv, SWIG_FromCharPtr("min_label"));
|
|
6774 |
+ SvREADONLY_on(sv); |
|
6775 |
+ } while(0) /*@SWIG@*/; |
|
6776 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6777 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_PASSWD", TRUE | 0x2 | GV_ADDMULTI); |
|
6778 |
+ sv_setsv(sv, SWIG_FromCharPtr("password"));
|
|
6779 |
+ SvREADONLY_on(sv); |
|
6780 |
+ } while(0) /*@SWIG@*/; |
|
6781 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6782 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_PASSWD_AUTOMATIC", TRUE | 0x2 | GV_ADDMULTI); |
|
6783 |
+ sv_setsv(sv, SWIG_FromCharPtr("automatic"));
|
|
6784 |
+ SvREADONLY_on(sv); |
|
6785 |
+ } while(0) /*@SWIG@*/; |
|
6786 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6787 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_PASSWD_MANUAL", TRUE | 0x2 | GV_ADDMULTI); |
|
6788 |
+ sv_setsv(sv, SWIG_FromCharPtr("manual"));
|
|
6789 |
+ SvREADONLY_on(sv); |
|
6790 |
+ } while(0) /*@SWIG@*/; |
|
6791 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6792 |
+ SV *sv = get_sv((char*) SWIG_prefix "USERATTR_TYPE_ROLE", TRUE | 0x2 | GV_ADDMULTI); |
|
6793 |
+ sv_setsv(sv, SWIG_FromCharPtr("role"));
|
|
6794 |
+ SvREADONLY_on(sv); |
|
6795 |
+ } while(0) /*@SWIG@*/; |
|
6796 |
+ SWIG_TypeClientData(SWIGTYPE_p_userstr_s, (void*) "secdb::userstr_t"); |
|
6797 |
+ SWIG_TypeClientData(SWIGTYPE_p_userattr_s, (void*) "secdb::userattr_t"); |
|
6798 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6799 |
+ SV *sv = get_sv((char*) SWIG_prefix "DEFAULT_POLICY", TRUE | 0x2 | GV_ADDMULTI); |
|
6800 |
+ sv_setsv(sv, SWIG_FromCharPtr("solaris"));
|
|
6801 |
+ SvREADONLY_on(sv); |
|
6802 |
+ } while(0) /*@SWIG@*/; |
|
6803 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6804 |
+ SV *sv = get_sv((char*) SWIG_prefix "SUSER_POLICY", TRUE | 0x2 | GV_ADDMULTI); |
|
6805 |
+ sv_setsv(sv, SWIG_FromCharPtr("suser"));
|
|
6806 |
+ SvREADONLY_on(sv); |
|
6807 |
+ } while(0) /*@SWIG@*/; |
|
6808 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6809 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_ACTION", TRUE | 0x2 | GV_ADDMULTI); |
|
6810 |
+ sv_setsv(sv, SWIG_FromCharPtr("act"));
|
|
6811 |
+ SvREADONLY_on(sv); |
|
6812 |
+ } while(0) /*@SWIG@*/; |
|
6813 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6814 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_COMMAND", TRUE | 0x2 | GV_ADDMULTI); |
|
6815 |
+ sv_setsv(sv, SWIG_FromCharPtr("cmd"));
|
|
6816 |
+ SvREADONLY_on(sv); |
|
6817 |
+ } while(0) /*@SWIG@*/; |
|
6818 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6819 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_JAVA_CLASS", TRUE | 0x2 | GV_ADDMULTI); |
|
6820 |
+ sv_setsv(sv, SWIG_FromCharPtr("java_class"));
|
|
6821 |
+ SvREADONLY_on(sv); |
|
6822 |
+ } while(0) /*@SWIG@*/; |
|
6823 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6824 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_JAVA_METHOD", TRUE | 0x2 | GV_ADDMULTI); |
|
6825 |
+ sv_setsv(sv, SWIG_FromCharPtr("java_method"));
|
|
6826 |
+ SvREADONLY_on(sv); |
|
6827 |
+ } while(0) /*@SWIG@*/; |
|
6828 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6829 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_ASSIGN", TRUE | 0x2 | GV_ADDMULTI); |
|
6830 |
+ sv_setsv(sv, SWIG_FromCharPtr("="));
|
|
6831 |
+ SvREADONLY_on(sv); |
|
6832 |
+ } while(0) /*@SWIG@*/; |
|
6833 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6834 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_DELIMITER", TRUE | 0x2 | GV_ADDMULTI); |
|
6835 |
+ sv_setsv(sv, SWIG_FromCharPtr(";"));
|
|
6836 |
+ SvREADONLY_on(sv); |
|
6837 |
+ } while(0) /*@SWIG@*/; |
|
6838 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6839 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_EMPTY", TRUE | 0x2 | GV_ADDMULTI); |
|
6840 |
+ sv_setsv(sv, SWIG_FromCharPtr(""));
|
|
6841 |
+ SvREADONLY_on(sv); |
|
6842 |
+ } while(0) /*@SWIG@*/; |
|
6843 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6844 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_ESCAPE", TRUE | 0x2 | GV_ADDMULTI); |
|
6845 |
+ sv_setsv(sv, SWIG_From_char SWIG_PERL_CALL_ARGS_1((char)('\\')));
|
|
6846 |
+ SvREADONLY_on(sv); |
|
6847 |
+ } while(0) /*@SWIG@*/; |
|
6848 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6849 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_ADD_KEYS", TRUE | 0x2 | GV_ADDMULTI); |
|
6850 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(16))); |
|
6851 |
+ SvREADONLY_on(sv); |
|
6852 |
+ } while(0) /*@SWIG@*/; |
|
6853 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6854 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_SPECIAL", TRUE | 0x2 | GV_ADDMULTI); |
|
6855 |
+ sv_setsv(sv, SWIG_FromCharPtr("=;:\\"));
|
|
6856 |
+ SvREADONLY_on(sv); |
|
6857 |
+ } while(0) /*@SWIG@*/; |
|
6858 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6859 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_TOKEN_DELIMIT", TRUE | 0x2 | GV_ADDMULTI); |
|
6860 |
+ sv_setsv(sv, SWIG_FromCharPtr(":"));
|
|
6861 |
+ SvREADONLY_on(sv); |
|
6862 |
+ } while(0) /*@SWIG@*/; |
|
6863 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6864 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_WILDCARD", TRUE | 0x2 | GV_ADDMULTI); |
|
6865 |
+ sv_setsv(sv, SWIG_FromCharPtr("*"));
|
|
6866 |
+ SvREADONLY_on(sv); |
|
6867 |
+ } while(0) /*@SWIG@*/; |
|
6868 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6869 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_WILDCHAR", TRUE | 0x2 | GV_ADDMULTI); |
|
6870 |
+ sv_setsv(sv, SWIG_From_char SWIG_PERL_CALL_ARGS_1((char)('*')));
|
|
6871 |
+ SvREADONLY_on(sv); |
|
6872 |
+ } while(0) /*@SWIG@*/; |
|
6873 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6874 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_ACTION_WILDCARD", TRUE | 0x2 | GV_ADDMULTI); |
|
6875 |
+ sv_setsv(sv, SWIG_FromCharPtr("*;*;*;*;*"));
|
|
6876 |
+ SvREADONLY_on(sv); |
|
6877 |
+ } while(0) /*@SWIG@*/; |
|
6878 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6879 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_FLAG_NONE", TRUE | 0x2 | GV_ADDMULTI); |
|
6880 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0x0000))); |
|
6881 |
+ SvREADONLY_on(sv); |
|
6882 |
+ } while(0) /*@SWIG@*/; |
|
6883 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6884 |
+ SV *sv = get_sv((char*) SWIG_prefix "KV_FLAG_REQUIRED", TRUE | 0x2 | GV_ADDMULTI); |
|
6885 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0x0001))); |
|
6886 |
+ SvREADONLY_on(sv); |
|
6887 |
+ } while(0) /*@SWIG@*/; |
|
6888 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6889 |
+ SV *sv = get_sv((char*) SWIG_prefix "ATTR_FOUND", TRUE | 0x2 | GV_ADDMULTI); |
|
6890 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(0))); |
|
6891 |
+ SvREADONLY_on(sv); |
|
6892 |
+ } while(0) /*@SWIG@*/; |
|
6893 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6894 |
+ SV *sv = get_sv((char*) SWIG_prefix "ATTR_NOT_FOUND", TRUE | 0x2 | GV_ADDMULTI); |
|
6895 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(-1))); |
|
6896 |
+ SvREADONLY_on(sv); |
|
6897 |
+ } while(0) /*@SWIG@*/; |
|
6898 |
+ /*@SWIG:/usr/share/swig/1.3.35/perl5/perltypemaps.swg,64,%set_constant@*/ do {
|
|
6899 |
+ SV *sv = get_sv((char*) SWIG_prefix "ATTR_NO_RECOVERY", TRUE | 0x2 | GV_ADDMULTI); |
|
6900 |
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(-2))); |
|
6901 |
+ SvREADONLY_on(sv); |
|
6902 |
+ } while(0) /*@SWIG@*/; |
|
6903 |
+ SWIG_TypeClientData(SWIGTYPE_p_kv_s, (void*) "secdb::kv_t"); |
|
6904 |
+ SWIG_TypeClientData(SWIGTYPE_p_kva_s, (void*) "secdb::kva_t"); |
|
6905 |
+ ST(0) = &PL_sv_yes; |
|
6906 |
+ XSRETURN(1); |
|
6907 |
+} |
|
6908 |
+ |