1 diff --git Python-2.6.4/Modules/authattr.c Python-2.6.4/Modules/authattr.c

     2 new file mode 100644

     3 --- /dev/null

     4 +++ Python-2.6.4/Modules/authattr.c

     5 @@ -0,0 +1,262 @@

     6 +/*

     7 + * CDDL HEADER START

     8 + *

     9 + * The contents of this file are subject to the terms of the

    10 + * Common Development and Distribution License (the "License").

    11 + * You may not use this file except in compliance with the License.

    12 + *

    13 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

    14 + * or http://www.opensolaris.org/os/licensing.

    15 + * See the License for the specific language governing permissions

    16 + * and limitations under the License.

    17 + *

    18 + * When distributing Covered Code, include this CDDL HEADER in each

    19 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

    20 + * If applicable, add the following below this CDDL HEADER, with the

    21 + * fields enclosed by brackets "[]" replaced with your own identifying

    22 + * information: Portions Copyright [yyyy] [name of copyright owner]

    23 + *

    24 + * CDDL HEADER END

    25 + */

    26 +

    27 +/*

    28 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

    29 + * Use is subject to license terms.

    30 + */

    31 +

    32 +/*

    33 + * RBAC Bindings for Python - auth_attr functions

    34 + */

    35 +

    36 +#include <auth_attr.h>

    37 +#include "Python.h"

    38 +#include "pyrbac.h"

    39 +

    40 +static PyObject*

    41 +pyrbac_setauthattr(PyObject* self, PyObject* args) {

    42 +	setauthattr();

    43 +	return Py_None;

    44 +}

    45 +

    46 +static PyObject*

    47 +pyrbac_endauthattr(PyObject* self, PyObject* args) {

    48 +	endauthattr();

    49 +	return Py_None;

    50 +}

    51 +

    52 +PyObject*

    53 +pyrbac_getauthnamattr(PyObject* self, char* authname, int mode) {

    54 +	

    55 +

    56 +	

    57 +	authattr_t * ret_authattr = (mode == PYRBAC_NAM_MODE) ? getauthnam(authname) : getauthattr();

    58 +	if (ret_authattr == NULL)

    59 +		return Py_None;

    60 +		

    61 +	PyObject* kv_data = PyDict_New();

    62 +	if (kv_data == NULL) {

    63 +		free_authattr(ret_authattr);

    64 +		return NULL;

    65 +	}

    66 +

    67 +	if(ret_authattr->attr != NULL) {

    68 +		int len;

    69 +		for(len = 0; len < ret_authattr->attr->length; len++) {

    70 +			kv_t current = ret_authattr->attr->data[len];

    71 +

    72 +			PyObject* set = PyList_New(NULL);

    73 +			char* saveptr;

    74 +			char* item = strtok_r(current.value, ",", &saveptr);

    75 +			PyList_Append(set, PyString_FromString(item));

    76 +

    77 +			while((item = strtok_r(NULL, ",", &saveptr)) != NULL) {

    78 +				if(PyList_Append(set, PyString_FromString(item)) != 0) {

    79 +					Py_XDECREF(set);

    80 +					Py_XDECREF(kv_data);

    81 +					free_authattr(ret_authattr);

    82 +					return NULL;

    83 +				}

    84 +			}

    85 +			if(PyDict_SetItemString(kv_data, current.key, set)) {

    86 +					free_authattr(ret_authattr);

    87 +					return NULL;

    88 +			}

    89 +		}

    90 +	}

    91 +	PyObject * retval = Py_BuildValue("{s:s,s:s,s:s,s:s,s:s,s:O}",

    92 +		"name",ret_authattr->name,

    93 +		"res1",ret_authattr->res1,

    94 +		"res2",ret_authattr->res2,

    95 +		"short",ret_authattr->short_desc,

    96 +		"long",ret_authattr->long_desc,

    97 +		"attributes",kv_data);

    98 +

    99 +	free_authattr(ret_authattr);

   100 +	return retval;

   101 +

   102 +}

   103 +

   104 +static PyObject*

   105 +pyrbac_getauthattr(PyObject* self, PyObject* args) {

   106 +	return(pyrbac_getauthnamattr(self, NULL, PYRBAC_ATTR_MODE));

   107 +}

   108 +

   109 +static PyObject*

   110 +pyrbac_getauthnam(PyObject* self, PyObject* args) {

   111 +	char* name = NULL;

   112 +	if(!PyArg_ParseTuple(args, "s:getauthnam", &name))

   113 +		return NULL;

   114 +	return(pyrbac_getauthnamattr(self, name, PYRBAC_NAM_MODE));

   115 +}

   116 +

   117 +static PyObject *

   118 +pyrbac_chkauthattr(PyObject* self, PyObject* args) {

   119 +	char* authstring = NULL;

   120 +	char* username = NULL;

   121 +	if(!PyArg_ParseTuple(args, "ss:chkauthattr", &authstring, &username))

   122 +		return NULL;

   123 +	return PyBool_FromLong((long)chkauthattr(authstring, username));

   124 +}

   125 +

   126 +static PyObject*

   127 +pyrbac_authattr_next(PyObject* self, PyObject* args) {

   128 +	PyObject* retval = pyrbac_getauthattr(self, args);

   129 +	if( retval == Py_None ) {

   130 +		setauthattr();

   131 +		return NULL;

   132 +	}

   133 +	return retval;

   134 +}

   135 +static PyObject*

   136 +pyrbac_authattr__iter__(PyObject* self, PyObject* args) {

   137 +	return self;

   138 +}

   139 +

   140 +typedef struct {

   141 +	PyObject_HEAD

   142 +} Authattr;

   143 +

   144 +static void

   145 +Authattr_dealloc(Authattr* self) {

   146 +	endauthattr();

   147 +	self->ob_type->tp_free((PyObject*) self);

   148 +}

   149 +

   150 +static PyObject*

   151 +Authattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {

   152 +	Authattr *self;

   153 +	self = (Authattr*)type->tp_alloc(type, 0);

   154 +

   155 +	return ((PyObject *) self);

   156 +}

   157 +

   158 +static int

   159 +Authattr_init(Authattr* self, PyObject *args, PyObject *kwargs) {

   160 +	setauthattr();

   161 +	return 0;

   162 +}

   163 +

   164 +static char pyrbac_authattr__doc__[];

   165 +

   166 +PyDoc_STRVAR(pyrbac_authattr__doc__, """provides interfaces to the auth_attr \

   167 +database. may be iterated over to return all auth_attr entries\n\n\

   168 +Methods provided:\n\

   169 +setauthattr\n\

   170 +endauthattr\n\

   171 +getauthattr\n\

   172 +chkauthattr\n\

   173 +getauthnam""");

   174 +

   175 +static char pyrbac_setauthattr__doc__[];

   176 +static char pyrbac_endauthattr__doc__[];

   177 +static char pyrbac_getauthattr__doc__[];

   178 +static char pyrbac_chkauthattr__doc__[];

   179 +

   180 +PyDoc_STRVAR(pyrbac_setauthattr__doc__, 

   181 +"\"rewinds\" the auth_attr functions to the first entry in the db. Called \

   182 +automatically by the constructor\n\tArguments: None\n\tReturns: None");

   183 +

   184 +PyDoc_STRVAR(pyrbac_endauthattr__doc__, 

   185 +"closes the auth_attr database, cleans up storage. called automatically by \

   186 +the destructor\n\tArguments: None\n\tReturns: None");

   187 +

   188 +PyDoc_STRVAR(pyrbac_chkauthattr__doc__, "verifies if a user has a given \

   189 +authorization.\n\tArguments: 2 Python strings, 'authname' and 'username'\n\

   190 +\tReturns: True if the user is authorized, False otherwise");

   191 +

   192 +PyDoc_STRVAR(pyrbac_getauthattr__doc__, 

   193 +"return one entry from the auth_attr database\n\

   194 +\tArguments: None\n\

   195 +\tReturns: a dict representing the authattr_t struct:\n\

   196 +\t\t\"name\": Authorization Name\n\

   197 +\t\t\"res1\": reserved\n\

   198 +\t\t\"res2\": reserved\n\

   199 +\t\t\"short\": Short Description\n\

   200 +\t\t\"long\": Long Description\n\

   201 +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \

   202 +or a string depending on value");

   203 +

   204 +PyDoc_STRVAR(pyrbac_getauthnam__doc__, 

   205 +"searches the auth_attr database for a given authorization name\n\

   206 +\tArguments: a Python string containing the auth name\n\

   207 +\tReturns: a dict representing the authattr_t struct:\n\

   208 +\t\t\"name\": Authorization Name\n\

   209 +\t\t\"res1\": reserved\n\

   210 +\t\t\"res2\": reserved\n\

   211 +\t\t\"short\": Short Description\n\

   212 +\t\t\"long\": Long Description\n\

   213 +\t\t\"attributes\": A Python dict keyed by attribute & valued as either a list \

   214 +or a string depending on value");

   215 +

   216 +static PyMethodDef Authattr_methods[] = {

   217 +	{"setauthattr", pyrbac_setauthattr, METH_NOARGS, pyrbac_setauthattr__doc__},

   218 +	{"endauthattr", pyrbac_endauthattr, METH_NOARGS, pyrbac_endauthattr__doc__},

   219 +	{"chkauthattr", pyrbac_chkauthattr, METH_VARARGS, pyrbac_chkauthattr__doc__},

   220 +	{"getauthattr", pyrbac_getauthattr, METH_NOARGS, pyrbac_getauthattr__doc__},

   221 +	{"getauthnam", pyrbac_getauthnam, METH_VARARGS, pyrbac_getauthnam__doc__},

   222 +	{NULL}

   223 +};

   224 +

   225 +PyTypeObject AuthattrType = {

   226 +	PyObject_HEAD_INIT(NULL)

   227 +	0,                         /*ob_size*/

   228 +	"rbac.authattr",             /*tp_name*/

   229 +	sizeof(Authattr),             /*tp_basicsize*/

   230 +	0,                         /*tp_itemsize*/

   231 +	(destructor)Authattr_dealloc, /*tp_dealloc*/

   232 +	0,                         /*tp_print*/

   233 +	0,                         /*tp_getattr*/

   234 +	0,                         /*tp_setattr*/

   235 +	0,                         /*tp_compare*/

   236 +	0,                         /*tp_repr*/

   237 +	0,                         /*tp_as_number*/

   238 +	0,                         /*tp_as_sequence*/

   239 +	0,                         /*tp_as_mapping*/

   240 +	0,                         /*tp_hash */

   241 +	0,                         /*tp_call*/

   242 +	0,                         /*tp_str*/

   243 +	0,                         /*tp_getattro*/

   244 +	0,                         /*tp_setattro*/

   245 +	0,                         /*tp_as_buffer*/

   246 +	Py_TPFLAGS_DEFAULT |

   247 +	Py_TPFLAGS_BASETYPE |

   248 +	Py_TPFLAGS_HAVE_ITER, /*tp_flags*/

   249 +	pyrbac_authattr__doc__,           /* tp_doc */

   250 +	0,		               /* tp_traverse */

   251 +	0,		               /* tp_clear */

   252 +	0,		               /* tp_richcompare */

   253 +	0,		               /* tp_weaklistoffset */

   254 +	pyrbac_authattr__iter__,		               /* tp_iter */

   255 +	pyrbac_authattr_next,         /* tp_iternext */

   256 +	Authattr_methods,             /* tp_methods */

   257 +	0,             /* tp_members */

   258 +	0,                         /* tp_getset */

   259 +	0,                         /* tp_base */

   260 +	0,                         /* tp_dict */

   261 +	0,                         /* tp_descr_get */

   262 +	0,                         /* tp_descr_set */

   263 +	0,                         /* tp_dictoffset */

   264 +	(initproc)Authattr_init,      /* tp_init */

   265 +	0,                         /* tp_alloc */

   266 +	Authattr_new,                 /* tp_new */

   267 +};

   268 diff --git Python-2.6.4/Modules/execattr.c Python-2.6.4/Modules/execattr.c

   269 new file mode 100644

   270 --- /dev/null

   271 +++ Python-2.6.4/Modules/execattr.c

   272 @@ -0,0 +1,314 @@

   273 +/*

   274 + * CDDL HEADER START

   275 + *

   276 + * The contents of this file are subject to the terms of the

   277 + * Common Development and Distribution License (the "License").

   278 + * You may not use this file except in compliance with the License.

   279 + *

   280 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   281 + * or http://www.opensolaris.org/os/licensing.

   282 + * See the License for the specific language governing permissions

   283 + * and limitations under the License.

   284 + *

   285 + * When distributing Covered Code, include this CDDL HEADER in each

   286 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   287 + * If applicable, add the following below this CDDL HEADER, with the

   288 + * fields enclosed by brackets "[]" replaced with your own identifying

   289 + * information: Portions Copyright [yyyy] [name of copyright owner]

   290 + *

   291 + * CDDL HEADER END

   292 + */

   293 +

   294 +/*

   295 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

   296 + * Use is subject to license terms.

   297 + */

   298 +

   299 +/*

   300 + * RBAC Bindings for Python - exec_attr functions

   301 + */

   302 +

   303 +#include <exec_attr.h>

   304 +#include "Python.h"

   305 +#include "pyrbac.h"

   306 +

   307 +static PyObject *

   308 +pyrbac_setexecattr(PyObject* self, PyObject* args) {

   309 +	setexecattr();

   310 +	return Py_None;

   311 +}

   312 +

   313 +static PyObject *

   314 +pyrbac_endexecattr(PyObject* self, PyObject* args) {

   315 +	endexecattr();

   316 +	return Py_None;

   317 +}

   318 +

   319 +PyObject *

   320 +pyrbac_getexecuserprofattr(PyObject* self, char* userprofname, char* type, char* id, int mode) {

   321 +

   322 +	PyObject* ep_data = (mode == PYRBAC_ATTR_MODE) ? NULL : PyList_New(0);

   323 +	

   324 +	if (ep_data == NULL && mode != PYRBAC_ATTR_MODE )

   325 +		return NULL;

   326 +	

   327 +	execattr_t *execprof;

   328 +	if (mode == PYRBAC_USER_MODE)

   329 +		execprof = getexecuser(userprofname, type, id, GET_ALL);

   330 +	else if (mode == PYRBAC_PROF_MODE)

   331 +		execprof = getexecprof(userprofname, type, id, GET_ALL);

   332 +	else if (mode == PYRBAC_ATTR_MODE)

   333 +		execprof = getexecattr();

   334 +	else

   335 +		return NULL;

   336 +

   337 +	if (execprof == NULL)

   338 +		return Py_None;

   339 +	

   340 +	execattr_t *execprof_head = execprof;

   341 +

   342 +	while(execprof != NULL) {

   343 +		

   344 +		PyObject* kv_data = PyDict_New();

   345 +

   346 +		if(execprof->attr != NULL) {

   347 +			int len;

   348 +			for(len = 0; len < execprof->attr->length; len++) {

   349 +				kv_t current = execprof->attr->data[len];

   350 +

   351 +				PyObject* set = PyList_New(NULL);

   352 +				char* saveptr;

   353 +				char* item = strtok_r(current.value, ",", &saveptr);

   354 +				PyList_Append(set, PyString_FromString(item));

   355 +

   356 +				while((item = strtok_r(NULL, ",", &saveptr)) != NULL) {

   357 +					if(PyList_Append(set, PyString_FromString(item)) != 0) {

   358 +						Py_XDECREF(set);

   359 +						Py_XDECREF(kv_data);

   360 +						free_execattr(execprof_head);

   361 +						return NULL;

   362 +					}

   363 +				}

   364 +				if(PyDict_SetItemString(kv_data, current.key, set)) {

   365 +						free_execattr(execprof_head);

   366 +						return NULL;

   367 +				}

   368 +			}

   369 +		}

   370 +		PyObject* entry = Py_BuildValue("{s:s,s:s,s:s,s:s,s:s,s:s,s:O}",

   371 +			"name", execprof->name,

   372 +			"type", execprof->type,

   373 +			"policy", execprof->policy,

   374 +			"res1", execprof->res1,

   375 +			"res2", execprof->res2,

   376 +			"id", execprof->id,

   377 +			"attributes", kv_data);

   378 +		

   379 +		if (entry == NULL) {

   380 +			Py_XDECREF(kv_data);

   381 +			free_execattr(execprof_head);

   382 +			return NULL;

   383 +		}

   384 +		

   385 +		if (mode == PYRBAC_ATTR_MODE) {

   386 +			free_execattr(execprof_head);

   387 +			return(entry);

   388 +		}

   389 +		PyList_Append(ep_data, entry);

   390 +		execprof = execprof->next;

   391 +	}

   392 +

   393 +	free_execattr(execprof_head);

   394 +	return(ep_data);

   395 + 

   396 +}

   397 +

   398 +static PyObject *

   399 +pyrbac_getexecuser(PyObject* self, PyObject* args) {

   400 +	char* username = NULL;

   401 +	char* type = NULL;

   402 +	char* id = NULL;

   403 +	

   404 +	if(!PyArg_ParseTuple(args, "sss:getexecuser", &username, &type, &id))

   405 +		return NULL;

   406 +

   407 +	return (pyrbac_getexecuserprofattr(self, username, type, id, PYRBAC_USER_MODE));

   408 +}

   409 +

   410 +static PyObject *

   411 +pyrbac_getexecprof(PyObject* self, PyObject* args) {

   412 +

   413 +	char* profname = NULL;

   414 +	char* type = NULL;

   415 +	char* id = NULL;

   416 +	

   417 +	if(!PyArg_ParseTuple(args, "sss:getexecprof", &profname, &type, &id))

   418 +		return NULL;

   419 +

   420 +	return (pyrbac_getexecuserprofattr(self, profname, type, id, PYRBAC_PROF_MODE));

   421 +}

   422 +

   423 +static PyObject*

   424 +pyrbac_getexecattr(PyObject* self, PyObject* args) {

   425 +	return pyrbac_getexecuserprofattr(self, NULL, NULL, NULL, PYRBAC_ATTR_MODE);

   426 +}

   427 +

   428 +static PyObject*

   429 +pyrbac_execattr_next(PyObject* self, PyObject* args) {

   430 +	PyObject* retval = pyrbac_getexecattr(self, args);

   431 +	if( retval == Py_None ) {

   432 +		setexecattr();

   433 +		return NULL;

   434 +	}

   435 +	return retval;

   436 +}

   437 +static PyObject*

   438 +pyrbac_execattr__iter__(PyObject* self, PyObject* args) {

   439 +	return self;

   440 +}

   441 +

   442 +typedef struct {

   443 +	PyObject_HEAD

   444 +} Execattr;

   445 +

   446 +static void

   447 +Execattr_dealloc(Execattr* self) {

   448 +	endexecattr();

   449 +	self->ob_type->tp_free((PyObject*) self);

   450 +}

   451 +

   452 +static PyObject*

   453 +Execattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {

   454 +	Execattr *self;

   455 +	self = (Execattr*)type->tp_alloc(type, 0);

   456 +

   457 +	return ((PyObject *) self);

   458 +}

   459 +

   460 +static int

   461 +Execattr_init(Execattr* self, PyObject *args, PyObject *kwargs) {

   462 +	setexecattr();

   463 +	return 0;

   464 +}

   465 +

   466 +static char pyrbac_execattr__doc__[];

   467 +

   468 +PyDoc_STRVAR(pyrbac_execattr__doc__, "provides functions for \

   469 +interacting with the execution profiles database. May be iterated over to \

   470 +enumerate exec_attr(4) entries\n\n\

   471 +Methods provided:\n\

   472 +setexecattr\n\

   473 +endexecattr\n\

   474 +getexecattr\n\

   475 +getexecprof\n\

   476 +getexecuser");

   477 +

   478 +

   479 +static char pyrbac_getexecuser__doc__[];

   480 +static char pyrbac_getexecprof__doc__[];

   481 +static char pyrbac_getexecattr__doc__[];

   482 +static char pyrbac_setexecattr__doc__[];

   483 +static char pyrbac_endexecattr__doc__[];

   484 +

   485 +PyDoc_STRVAR(pyrbac_setexecattr__doc__,

   486 +"\"rewinds\" the exec_attr functions to the first entry in the db. Called \

   487 +automatically by the constructor.\n\

   488 +\tArguments: None\

   489 +\tReturns: None");

   490 +

   491 +PyDoc_STRVAR(pyrbac_endexecattr__doc__, 

   492 +"closes the exec_attr database, cleans up storage. called automatically by \

   493 +the destructor.\n\

   494 +\tArguments: None\

   495 +\tReturns: None");

   496 +

   497 +PyDoc_STRVAR(pyrbac_getexecuser__doc__, "corresponds with getexecuser(3SECDB)\

   498 +\nTakes: \'username\', \'type\', \'id\'\n\

   499 +Return: a single exec_attr entry\n\

   500 +\tArguments: None\n\

   501 +\tReturns: a dict representation of an execattr_t struct:\n\

   502 +\t\t\"name\": Authorization Name\n\

   503 +\t\t\"type\": Profile Type\n\

   504 +\t\t\"policy\": Policy attributes are relevant in\n\

   505 +\t\t\"res1\": reserved\n\

   506 +\t\t\"res2\": reserved\n\

   507 +\t\t\"id\": unique identifier\n\

   508 +\t\t\"attributes\": A Python dict keyed by attribute & valued as\

   509 +either a list or a string depending on value");

   510 +

   511 +PyDoc_STRVAR(pyrbac_getexecprof__doc__, "corresponds with getexecprof(3SECDB)\

   512 +\nTakes: \'profile name\', \'type\', \'id\'\n\

   513 +\tReturns: a dict representation of an execattr_t struct:\n\

   514 +\t\t\"name\": Authorization Name\n\

   515 +\t\t\"type\": Profile Type\n\

   516 +\t\t\"policy\": Policy attributes are relevant in\n\

   517 +\t\t\"res1\": reserved\n\

   518 +\t\t\"res2\": reserved\n\

   519 +\t\t\"id\": unique identifier\n\

   520 +\t\t\"attributes\": A Python dict keyed by attribute & valued as\

   521 +either a list or a string depending on value");

   522 +

   523 +PyDoc_STRVAR(pyrbac_getexecattr__doc__, "corresponds with getexecattr(3SECDB)\

   524 +\nTakes 0 arguments\n\

   525 +\tReturns: a dict representation of an execattr_t struct:\n\

   526 +\t\t\"name\": Authorization Name\n\

   527 +\t\t\"type\": Profile Type\n\

   528 +\t\t\"policy\": Policy attributes are relevant in\n\

   529 +\t\t\"res1\": reserved\n\

   530 +\t\t\"res2\": reserved\n\

   531 +\t\t\"id\": unique identifier\n\

   532 +\t\t\"attributes\": A Python dict keyed by attribute & valued as\

   533 +either a list or a string depending on value");

   534 +

   535 +static PyMethodDef Execattr_methods[] = {

   536 +	{"setexecattr", pyrbac_setexecattr, METH_NOARGS, pyrbac_setexecattr__doc__},

   537 +	{"endexecattr", pyrbac_endexecattr, METH_NOARGS, pyrbac_endexecattr__doc__},

   538 +	{"getexecprof", pyrbac_getexecprof, METH_VARARGS, pyrbac_getexecprof__doc__},	

   539 +	{"getexecuser", pyrbac_getexecuser, METH_VARARGS, pyrbac_getexecuser__doc__},

   540 +	{"getexecattr", pyrbac_getexecattr, METH_NOARGS, pyrbac_getexecattr__doc__},

   541 +	{NULL}

   542 +};

   543 +

   544 +PyTypeObject ExecattrType = {

   545 +	PyObject_HEAD_INIT(NULL)

   546 +	0,                         /*ob_size*/

   547 +	"rbac.execattr",             /*tp_name*/

   548 +	sizeof(Execattr),             /*tp_basicsize*/

   549 +	0,                         /*tp_itemsize*/

   550 +	(destructor)Execattr_dealloc, /*tp_dealloc*/

   551 +	0,                         /*tp_print*/

   552 +	0,                         /*tp_getattr*/

   553 +	0,                         /*tp_setattr*/

   554 +	0,                         /*tp_compare*/

   555 +	0,                         /*tp_repr*/

   556 +	0,                         /*tp_as_number*/

   557 +	0,                         /*tp_as_sequence*/

   558 +	0,                         /*tp_as_mapping*/

   559 +	0,                         /*tp_hash */

   560 +	0,                         /*tp_call*/

   561 +	0,                         /*tp_str*/

   562 +	0,                         /*tp_getattro*/

   563 +	0,                         /*tp_setattro*/

   564 +	0,                         /*tp_as_buffer*/

   565 +	Py_TPFLAGS_DEFAULT |

   566 +	Py_TPFLAGS_BASETYPE |

   567 +	Py_TPFLAGS_HAVE_ITER, /*tp_flags*/

   568 +	pyrbac_execattr__doc__,           /* tp_doc */

   569 +	0,		               /* tp_traverse */

   570 +	0,		               /* tp_clear */

   571 +	0,		               /* tp_richcompare */

   572 +	0,		               /* tp_weaklistoffset */

   573 +	pyrbac_execattr__iter__,		               /* tp_iter */

   574 +	pyrbac_execattr_next,         /* tp_iternext */

   575 +	Execattr_methods,             /* tp_methods */

   576 +	0,             /* tp_members */

   577 +	0,                         /* tp_getset */

   578 +	0,                         /* tp_base */

   579 +	0,                         /* tp_dict */

   580 +	0,                         /* tp_descr_get */

   581 +	0,                         /* tp_descr_set */

   582 +	0,                         /* tp_dictoffset */

   583 +	(initproc)Execattr_init,      /* tp_init */

   584 +	0,                         /* tp_alloc */

   585 +	Execattr_new,                 /* tp_new */

   586 +};

   587 diff --git Python-2.6.4/Modules/privileges.c Python-2.6.4/Modules/privileges.c

   588 new file mode 100644

   589 --- /dev/null

   590 +++ Python-2.6.4/Modules/privileges.c

   591 @@ -0,0 +1,230 @@

   592 +/*

   593 + * CDDL HEADER START

   594 + *

   595 + * The contents of this file are subject to the terms of the

   596 + * Common Development and Distribution License (the "License").

   597 + * You may not use this file except in compliance with the License.

   598 + *

   599 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   600 + * or http://www.opensolaris.org/os/licensing.

   601 + * See the License for the specific language governing permissions

   602 + * and limitations under the License.

   603 + *

   604 + * When distributing Covered Code, include this CDDL HEADER in each

   605 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   606 + * If applicable, add the following below this CDDL HEADER, with the

   607 + * fields enclosed by brackets "[]" replaced with your own identifying

   608 + * information: Portions Copyright [yyyy] [name of copyright owner]

   609 + *

   610 + * CDDL HEADER END

   611 + */

   612 +

   613 +/*

   614 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

   615 + * Use is subject to license terms.

   616 + */

   617 +

   618 +/*

   619 + * privileges(5) bindings for Python

   620 + */

   621 +

   622 +#include <priv.h>

   623 +#include "Python.h"

   624 +

   625 +static PyObject *

   626 +pyprivileges_setppriv( PyObject *self, PyObject *args) {

   627 +	priv_op_t op = -1 ; 

   628 +	priv_ptype_t which = NULL;

   629 +

   630 +	PyObject* set_list = NULL;

   631 +

   632 +	priv_set_t * set = NULL;

   633 +

   634 +	if(!PyArg_ParseTuple(args, "iiO:setppriv", &op, &which, &set_list))

   635 +		return NULL;

   636 +	

   637 +	if((op != PRIV_ON && op != PRIV_OFF && op != PRIV_SET) ||

   638 +		(which != PRIV_PERMITTED && which != PRIV_EFFECTIVE &&

   639 +		which != PRIV_INHERITABLE && which != PRIV_LIMIT))

   640 +		return NULL;

   641 +	

   642 +	PyObject* set_string = PyList_GetItem(set_list, 0);

   643 +	int i;

   644 +	for (i = 1; i < PyList_Size(set_list); ++i) {

   645 +		PyString_Concat(&set_string, PyString_FromString(","));

   646 +		PyString_Concat(&set_string, PyList_GetItem(set_list, i));

   647 +	}

   648 +

   649 +	set = priv_str_to_set(PyString_AsString(set_string), ",", NULL );

   650 +

   651 +	if ( set == NULL )

   652 +		return NULL;

   653 +

   654 +	long ret = (long) setppriv(op, which, set);

   655 +	priv_freeset(set);	

   656 +	// Python inverts true & false

   657 +	if(ret)

   658 +		Py_RETURN_FALSE;

   659 +	

   660 +	Py_RETURN_TRUE;

   661 +}

   662 +

   663 +static PyObject *

   664 +pyprivileges_getppriv( PyObject *self, PyObject *args) {

   665 +

   666 +	char* set_str = NULL;

   667 +	priv_ptype_t which = NULL;

   668 +	priv_set_t * set = priv_allocset();

   669 +	if (set == NULL)

   670 +		return NULL;

   671 +

   672 +	if(!PyArg_ParseTuple(args, "i:getppriv", &which))

   673 +		return NULL;

   674 +

   675 +	if (which != PRIV_PERMITTED && which != PRIV_EFFECTIVE &&

   676 +	which != PRIV_INHERITABLE && which != PRIV_LIMIT)

   677 +		return NULL;

   678 +

   679 +	if (getppriv(which, set) != 0)

   680 +		return NULL;

   681 +	

   682 +	set_str = priv_set_to_str(set, ',', PRIV_STR_LIT);

   683 +	priv_freeset(set);

   684 +	

   685 +	PyObject* set_list = PyList_New(NULL);

   686 +	char* saveptr;

   687 +	char* item = strtok_r(set_str, ",", &saveptr);

   688 +	PyList_Append(set_list, PyString_FromString(item));

   689 +

   690 +	while((item = strtok_r(NULL, ",", &saveptr)) != NULL) {

   691 +		if(PyList_Append(set_list, PyString_FromString(item)) != 0) {

   692 +			Py_XDECREF(set_list);

   693 +			return NULL;

   694 +		}

   695 +	}

   696 +

   697 +	return(set_list);

   698 +}

   699 +

   700 +static PyObject *

   701 +pyprivileges_priv_inverse( PyObject *self, PyObject *args ) {

   702 +

   703 +	PyObject* set_list_in = NULL;

   704 +	if(!PyArg_ParseTuple(args, "O:priv_inverse", &set_list_in))

   705 +		return NULL;

   706 +

   707 +	PyObject* set_string = PyList_GetItem(set_list_in, 0);

   708 +	int i;

   709 +	for (i = 1; i < PyList_Size(set_list_in); ++i) {

   710 +		PyString_Concat(set_string, PyString_FromString(","));

   711 +		PyString_Concat(set_string, PyList_GetItem(set_list_in, i));

   712 +	}

   713 +

   714 +	priv_set_t * set = priv_str_to_set(PyString_AsString(set_string), ",", NULL);

   715 +	if (set == NULL)

   716 +		return NULL;

   717 +	priv_inverse(set);

   718 +	char * ret_str = priv_set_to_str(set, ',', PRIV_STR_LIT);

   719 +	priv_freeset(set);

   720 +	

   721 +	PyObject* set_list_out = PyList_New(NULL);

   722 +	char* saveptr;

   723 +	char* item = strtok_r(ret_str, ",", &saveptr);

   724 +	PyList_Append(set_list_out, PyString_FromString(item));

   725 +

   726 +	while((item = strtok_r(NULL, ",", &saveptr)) != NULL) {

   727 +		if(PyList_Append(set_list_out, PyString_FromString(item)) != 0) {

   728 +			Py_XDECREF(set_list_out);

   729 +			return NULL;

   730 +		}

   731 +	}

   732 +	

   733 +	Py_XDECREF(set_list_in);

   734 +	

   735 +	return(set_list_out);

   736 +}

   737 +

   738 +/* priv_ineffect is a convienient wrapper to priv_get

   739 + * however priv_set is, in the context of python, not

   740 + * much of a convienience, so it's omitted

   741 + */

   742 +static PyObject * 

   743 +pyprivileges_priv_ineffect(PyObject* self, PyObject* args) {

   744 +	char* privstring=NULL;

   745 +	if (!PyArg_ParseTuple(args, "s:priv_ineffect", &privstring))

   746 +		return NULL;

   747 +	return PyBool_FromLong(priv_ineffect(privstring));

   748 +}

   749 +

   750 +

   751 +static char pyprivileges__doc__[];

   752 +PyDoc_STRVAR(pyprivileges__doc__, 

   753 +"Provides functions for interacting with the Solaris privileges(5) framework\n\

   754 +Functions provided:\n\

   755 +setppriv\n\

   756 +getppriv\n\

   757 +priv_ineffect\n\

   758 +priv_inverse");

   759 +

   760 +static char pyprivileges_setppriv__doc__[];

   761 +static char pyprivileges_getppriv__doc__[];

   762 +static char pyprivileges_priv_ineffect__doc__[];

   763 +static char pyprivileges_priv_inverse__doc__[];

   764 +

   765 +PyDoc_STRVAR(pyprivileges_setppriv__doc__, 

   766 +"Facilitates setting the permitted/inheritable/limit/effective privileges set\n\

   767 +\tArguments:\n\

   768 +\t\tone of (PRIV_ON|PRIV_OFF|PRIV_SET)\n\

   769 +\t\tone of (PRIV_PERMITTED|PRIV_INHERITABLE|PRIV_LIMIT|PRIV_EFFECTIVE)\n\

   770 +\t\tset of privileges: a list of strings\n\

   771 +\tReturns: True on success, False on failure\

   772 +");

   773 +

   774 +PyDoc_STRVAR(pyprivileges_getppriv__doc__, 

   775 +"Return the process privilege set\n\

   776 +\tArguments:\n\

   777 +\t\tone of (PRIV_PERMITTED|PRIV_INHERITABLE|PRIV_LIMIT|PRIV_EFFECTIVE)\n\

   778 +\tReturns: a Python list of strings");

   779 +	

   780 +PyDoc_STRVAR(pyprivileges_priv_ineffect__doc__, 

   781 +"Checks for a privileges presence in the effective set\n\

   782 +\tArguments: a String\n\

   783 +\tReturns: True if the privilege is in effect, False otherwise");

   784 +

   785 +PyDoc_STRVAR(pyprivileges_priv_inverse__doc__, 

   786 +"The complement of the set of privileges\n\

   787 +\tArguments: a list of strings\n\tReturns: a list of strings");

   788 +

   789 +static PyMethodDef module_methods[] = {

   790 +	{"setppriv", pyprivileges_setppriv, METH_VARARGS, pyprivileges_setppriv__doc__}, 

   791 +	{"getppriv", pyprivileges_getppriv, METH_VARARGS, pyprivileges_getppriv__doc__}, 

   792 +	{"priv_ineffect", pyprivileges_priv_ineffect, METH_VARARGS, pyprivileges_priv_ineffect__doc__},

   793 +	{"priv_inverse", pyprivileges_priv_inverse, METH_VARARGS, pyprivileges_priv_inverse__doc__},

   794 +	{NULL}

   795 +};

   796 +

   797 +

   798 +#ifndef PyMODINIT_FUNC	/* declarations for DLL import/export */

   799 +#define PyMODINIT_FUNC void

   800 +#endif

   801 +PyMODINIT_FUNC

   802 +initprivileges(void) {

   803 +	PyObject* m;

   804 +

   805 +	m = Py_InitModule3("privileges", module_methods, pyprivileges__doc__);

   806 +		if ( m == NULL )

   807 +		return;

   808 +		

   809 +	PyObject* d = PyModule_GetDict(m);

   810 +	if (d == NULL)

   811 +		return;

   812 +

   813 +	PyDict_SetItemString(d, "PRIV_ON", PyInt_FromLong((long)PRIV_ON));

   814 +	PyDict_SetItemString(d, "PRIV_OFF", PyInt_FromLong((long)PRIV_OFF));

   815 +	PyDict_SetItemString(d, "PRIV_SET", PyInt_FromLong((long)PRIV_SET));

   816 +

   817 +	PyDict_SetItemString(d, "PRIV_PERMITTED", PyInt_FromLong((long)PRIV_PERMITTED));

   818 +	PyDict_SetItemString(d, "PRIV_INHERITABLE", PyInt_FromLong((long)PRIV_INHERITABLE));

   819 +	PyDict_SetItemString(d, "PRIV_LIMIT", PyInt_FromLong((long)PRIV_LIMIT));

   820 +	PyDict_SetItemString(d, "PRIV_EFFECTIVE", PyInt_FromLong((long)PRIV_EFFECTIVE));

   821 +}

   822 diff --git Python-2.6.4/Modules/pyrbac.c Python-2.6.4/Modules/pyrbac.c

   823 new file mode 100644

   824 --- /dev/null

   825 +++ Python-2.6.4/Modules/pyrbac.c

   826 @@ -0,0 +1,69 @@

   827 +/*

   828 + * CDDL HEADER START

   829 + *

   830 + * The contents of this file are subject to the terms of the

   831 + * Common Development and Distribution License (the "License").

   832 + * You may not use this file except in compliance with the License.

   833 + *

   834 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   835 + * or http://www.opensolaris.org/os/licensing.

   836 + * See the License for the specific language governing permissions

   837 + * and limitations under the License.

   838 + *

   839 + * When distributing Covered Code, include this CDDL HEADER in each

   840 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   841 + * If applicable, add the following below this CDDL HEADER, with the

   842 + * fields enclosed by brackets "[]" replaced with your own identifying

   843 + * information: Portions Copyright [yyyy] [name of copyright owner]

   844 + *

   845 + * CDDL HEADER END

   846 + */

   847 +

   848 +/*

   849 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

   850 + * Use is subject to license terms.

   851 + */

   852 +

   853 +/*

   854 + * RBAC Bindings for Python

   855 + */

   856 +

   857 +#include <Python.h>

   858 +#include "pyrbac.h"

   859 +

   860 +static PyMethodDef module_methods[] = {NULL};

   861 +static char pyrbac__doc__[];

   862 +

   863 +PyDoc_STRVAR(pyrbac__doc__, "provides access to some objects \

   864 +for interaction with the Solaris Role-Based Access Control \

   865 +framework.\n\nDynamic objects:\n\

   866 +userattr -- for interacting with user_attr(4)\n\

   867 +authattr -- for interacting with auth_attr(4)\n\

   868 +execattr -- for interacting with exec_attr(4)\n");

   869 +

   870 +#ifndef PyMODINIT_FUNC	/* declarations for DLL import/export */

   871 +#define PyMODINIT_FUNC void

   872 +#endif

   873 +PyMODINIT_FUNC

   874 +initrbac(void) {

   875 +	PyObject* m;

   876 +	if (PyType_Ready(&AuthattrType) < 0 || 

   877 +		PyType_Ready(&ExecattrType) < 0 ||

   878 +		PyType_Ready(&UserattrType) < 0 )

   879 +		return;

   880 +

   881 +	m = Py_InitModule3("rbac", module_methods, pyrbac__doc__);

   882 +	if ( m == NULL )

   883 +		return;

   884 +	

   885 +	Py_INCREF(&AuthattrType);

   886 +	PyModule_AddObject(m, "authattr", (PyObject*)&AuthattrType);

   887 +

   888 +	Py_INCREF(&ExecattrType);

   889 +	PyModule_AddObject(m, "execattr", (PyObject*)&ExecattrType);

   890 +

   891 +	Py_INCREF(&UserattrType);

   892 +	PyModule_AddObject(m, "userattr", (PyObject*)&UserattrType);

   893 +

   894 +}

   895 +

   896 diff --git Python-2.6.4/Modules/pyrbac.h Python-2.6.4/Modules/pyrbac.h

   897 new file mode 100644

   898 --- /dev/null

   899 +++ Python-2.6.4/Modules/pyrbac.h

   900 @@ -0,0 +1,46 @@

   901 +/*

   902 + * CDDL HEADER START

   903 + *

   904 + * The contents of this file are subject to the terms of the

   905 + * Common Development and Distribution License (the "License").

   906 + * You may not use this file except in compliance with the License.

   907 + *

   908 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   909 + * or http://www.opensolaris.org/os/licensing.

   910 + * See the License for the specific language governing permissions

   911 + * and limitations under the License.

   912 + *

   913 + * When distributing Covered Code, include this CDDL HEADER in each

   914 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   915 + * If applicable, add the following below this CDDL HEADER, with the

   916 + * fields enclosed by brackets "[]" replaced with your own identifying

   917 + * information: Portions Copyright [yyyy] [name of copyright owner]

   918 + *

   919 + * CDDL HEADER END

   920 + */

   921 +

   922 +/*

   923 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

   924 + * Use is subject to license terms.

   925 + */

   926 +

   927 +/* 

   928 + * RBAC bindings for python

   929 + */

   930 +#ifndef PYRBAC_H

   931 +#define PYRBAC_H

   932 +

   933 +#include <secdb.h>

   934 +

   935 +

   936 +#define PYRBAC_USER_MODE 1

   937 +#define PYRBAC_PROF_MODE 2

   938 +#define PYRBAC_ATTR_MODE 3

   939 +#define PYRBAC_NAM_MODE 4

   940 +#define PYRBAC_UID_MODE 5

   941 +

   942 +PyTypeObject AuthattrType;

   943 +PyTypeObject ExecattrType;

   944 +PyTypeObject UserattrType;

   945 +

   946 +#endif

   947 diff --git Python-2.6.4/Modules/userattr.c Python-2.6.4/Modules/userattr.c

   948 new file mode 100644

   949 --- /dev/null

   950 +++ Python-2.6.4/Modules/userattr.c

   951 @@ -0,0 +1,309 @@

   952 +/*

   953 + * CDDL HEADER START

   954 + *

   955 + * The contents of this file are subject to the terms of the

   956 + * Common Development and Distribution License (the "License").

   957 + * You may not use this file except in compliance with the License.

   958 + *

   959 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   960 + * or http://www.opensolaris.org/os/licensing.

   961 + * See the License for the specific language governing permissions

   962 + * and limitations under the License.

   963 + *

   964 + * When distributing Covered Code, include this CDDL HEADER in each

   965 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   966 + * If applicable, add the following below this CDDL HEADER, with the

   967 + * fields enclosed by brackets "[]" replaced with your own identifying

   968 + * information: Portions Copyright [yyyy] [name of copyright owner]

   969 + *

   970 + * CDDL HEADER END

   971 + */

   972 +

   973 +/*

   974 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

   975 + * Use is subject to license terms.

   976 + */

   977 +

   978 +/*

   979 + * RBAC Bindings for Python - user_attr functions

   980 + */

   981 +

   982 +#include <stdio.h>

   983 +#include <user_attr.h>

   984 +#include "Python.h"

   985 +#include "pyrbac.h"

   986 +

   987 +static PyObject*

   988 +pyrbac_setuserattr(PyObject* self, PyObject* args) {

   989 +	setuserattr();

   990 +	return Py_None;

   991 +}

   992 +

   993 +static PyObject*

   994 +pyrbac_enduserattr(PyObject* self, PyObject* args) {

   995 +	enduserattr();

   996 +	return Py_None;

   997 +}

   998 +

   999 +PyObject*

  1000 +pyrbac_getuseruidnamattr(PyObject* self, void* arg, int mode, char* filename) {

  1001 +	

  1002 +	userattr_t *ret_userattr;

  1003 +

  1004 +	if (mode == PYRBAC_ATTR_MODE) {

  1005 +	    if (filename != NULL) {

  1006 +            FILE* file = fopen(filename, "r");

  1007 +            if (file == NULL)

  1008 +                return NULL;

  1009 +	        ret_userattr = fgetuserattr(file);

  1010 +	        if (fclose(file))

  1011 +                return NULL;

  1012 +	    }

  1013 +	    else

  1014 +	    	ret_userattr = getuserattr();

  1015 +	}

  1016 +	else if (mode == PYRBAC_NAM_MODE)

  1017 +		ret_userattr = getusernam((char*) arg);

  1018 +	else if (mode == PYRBAC_UID_MODE)

  1019 +		ret_userattr = getuseruid(*((uid_t*) arg));

  1020 +	

  1021 +	if (ret_userattr == NULL)

  1022 +		return Py_None;

  1023 +	

  1024 +	PyObject* entry = PyTuple_New(5);

  1025 +	if (entry == NULL) {

  1026 +		free_userattr(ret_userattr);

  1027 +		return NULL;

  1028 +	}

  1029 +	

  1030 +	PyObject* kv_data = PyDict_New();

  1031 +

  1032 +	if(ret_userattr->attr != NULL) {

  1033 +		int len;

  1034 +		for(len = 0; len < ret_userattr->attr->length; len++) {

  1035 +			kv_t current = ret_userattr->attr->data[len];

  1036 +

  1037 +			PyObject* set = PyList_New(NULL);

  1038 +			char* saveptr;

  1039 +			char* item = strtok_r(current.value, ",", &saveptr);

  1040 +			PyList_Append(set, PyString_FromString(item));

  1041 +

  1042 +			while((item = strtok_r(NULL, ",", &saveptr)) != NULL) {

  1043 +				if(PyList_Append(set, PyString_FromString(item)) != 0) {

  1044 +					Py_XDECREF(set);

  1045 +					Py_XDECREF(kv_data);

  1046 +					free_userattr(ret_userattr);

  1047 +					return NULL;

  1048 +				}

  1049 +			}

  1050 +			if(PyDict_SetItemString(kv_data, current.key, set)) {

  1051 +					free_userattr(ret_userattr);

  1052 +					return NULL;

  1053 +			}

  1054 +		}

  1055 +	}

  1056 +	entry = Py_BuildValue("{s:s,s:s,s:s,s:s,s:O}", 

  1057 +		"name", ret_userattr->name,

  1058 +		"qualifier", ret_userattr->qualifier,

  1059 +		"res1", ret_userattr->res1,

  1060 +		"res2", ret_userattr->res2,

  1061 +		"attributes", kv_data);

  1062 +

  1063 +	free_userattr(ret_userattr);

  1064 +	

  1065 +	return entry;

  1066 +}

  1067 +

  1068 +

  1069 +static PyObject*

  1070 +pyrbac_getuserattr(PyObject* self, PyObject* args) {

  1071 +	return(pyrbac_getuseruidnamattr(self, (void*) NULL, PYRBAC_ATTR_MODE, NULL));

  1072 +}

  1073 +

  1074 +static PyObject*

  1075 +pyrbac_fgetuserattr(PyObject* self, PyObject* args) {

  1076 +	char* filename = NULL;

  1077 +	if(!PyArg_ParseTuple(args, "s:fgetuserattr", &filename))

  1078 +		return NULL;

  1079 +	return(pyrbac_getuseruidnamattr(self, NULL, PYRBAC_ATTR_MODE, filename));

  1080 +}

  1081 +

  1082 +static PyObject*

  1083 +pyrbac_getusernam(PyObject* self, PyObject* args) {

  1084 +	char* name = NULL;

  1085 +	if(!PyArg_ParseTuple(args, "s:getusernam", &name))

  1086 +		return NULL;

  1087 +	return(pyrbac_getuseruidnamattr(self, (void*) name, PYRBAC_NAM_MODE, NULL));

  1088 +}

  1089 +

  1090 +static PyObject*

  1091 +pyrbac_getuseruid(PyObject* self, PyObject* args) {

  1092 +	uid_t uid;

  1093 +	if(!PyArg_ParseTuple(args, "i:getuseruid", &uid))

  1094 +		return NULL;

  1095 +	return(pyrbac_getuseruidnamattr(self, (void*) &uid, PYRBAC_UID_MODE, NULL));

  1096 +}

  1097 +

  1098 +static PyObject*

  1099 +pyrbac_userattr_next(PyObject* self, PyObject* args) {

  1100 +	PyObject* retval = pyrbac_getuserattr(self, args);

  1101 +	if( retval == Py_None ) {

  1102 +		setuserattr();

  1103 +		return NULL;

  1104 +	}

  1105 +	return retval;

  1106 +}

  1107 +static PyObject*

  1108 +pyrbac_userattr__iter__(PyObject* self, PyObject* args) {

  1109 +	return self;

  1110 +}

  1111 +

  1112 +typedef struct {

  1113 +	PyObject_HEAD

  1114 +} Userattr;

  1115 +

  1116 +static void

  1117 +Userattr_dealloc(Userattr* self) {

  1118 +	enduserattr();

  1119 +	self->ob_type->tp_free((PyObject*) self);

  1120 +}

  1121 +

  1122 +static PyObject*

  1123 +Userattr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {

  1124 +	Userattr *self;

  1125 +	self = (Userattr*)type->tp_alloc(type, 0);

  1126 +

  1127 +	return ((PyObject *) self);

  1128 +}

  1129 +

  1130 +static int

  1131 +Userattr_init(Userattr* self, PyObject *args, PyObject *kwargs) {

  1132 +	setuserattr();

  1133 +	return 0;

  1134 +}