[projects/pld-ftp-admin.git] / ucred / ucred.c

#include <Python.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>

PyObject *g_socketerror; // socket.error

static PyObject *ucred_sendcreds(PyObject *self, PyObject *args, PyObject *keywds);
static PyObject *ucred_recvcreds(PyObject *self, PyObject *args, PyObject *keywds);

static PyMethodDef ucredMethods[] = {
    {"sendcreds", (PyCFunction)ucred_sendcreds, METH_VARARGS|METH_KEYWORDS, NULL},
    {"recvcreds", (PyCFunction)ucred_recvcreds, METH_VARARGS|METH_KEYWORDS, NULL},
    {NULL, NULL, 0, NULL}
};

void initucred(void) {
    PyObject *module;
    module = Py_InitModule("ucred", ucredMethods);

	if(-1 == PyModule_AddIntConstant(module, "SO_PASSCRED", SO_PASSCRED)) {
		return;
	}

    module = PyImport_ImportModule("socket");
    if(!module) {
        return;
    }
    g_socketerror = PyObject_GetAttrString(module, "error");
    if(!g_socketerror) {
        return;
    }
}

static PyObject *ucred_sendcreds(PyObject *self, PyObject *args, PyObject *keywds) {
    int fd;
    int ret;
    int pid=-1, uid=-1, gid=-1;
    struct msghdr msg;
    struct iovec iov[1];
	struct ucred uc;
	unsigned char control[CMSG_SPACE(sizeof(struct ucred))];
	struct cmsghdr *cur;

    static char *kwlist[] = {"fd",
							 "pid",
							 "uid",
							 "gid",
							 NULL};

//    kill(0, SIGTRAP);
    if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|iii", kwlist, 
				&fd,
				&pid,
				&uid,
				&gid)) {
        return NULL;
    }
//    kill(0, SIGTRAP);

	if(pid!=-1)
		uc.pid=pid;
	else
		uc.pid=getpid();
	if(uid!=-1)
		uc.uid=uid;
	else
		uc.uid=getuid();
	if(gid!=-1)
		uc.gid=gid;
	else
		uc.gid=getgid();

	iov[0].iov_base="SCM_CREDENTIALS";
	iov[0].iov_len=15;

	memset(&msg, 0, sizeof(msg));
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
	msg.msg_control = &control;
	msg.msg_controllen = sizeof(control);

	cur = CMSG_FIRSTHDR(&msg);
	cur->cmsg_level = SOL_SOCKET;
	cur->cmsg_type = SCM_CREDENTIALS;
	cur->cmsg_len = CMSG_SPACE(sizeof(struct ucred));
	memcpy(CMSG_DATA(cur), &uc, sizeof(struct ucred));

    ret = sendmsg(fd, &msg, 0);
    if(ret < 0) {
        PyErr_SetFromErrno(g_socketerror);
        return NULL;
    }

    return Py_BuildValue("i", ret);
}

static PyObject *ucred_recvcreds(PyObject *self, PyObject *args, PyObject *keywds) {
    int fd;
    int flags=0;
    size_t maxsize=1024;
	char control[CMSG_SPACE(sizeof(struct ucred))];
    int ret;
	int pid=-1, uid=-1, gid=-1;
    struct msghdr msg;
    struct iovec iov[1];
	struct cmsghdr *cur;
	struct ucred *uc;


    static char *kwlist[] = {"fd", "flags", "maxsize", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|ii", kwlist,
            &fd, &flags, &maxsize)) {
        return NULL;
    }

	memset(&msg, 0, sizeof(msg));

    iov[0].iov_len = maxsize;
    iov[0].iov_base = malloc(maxsize);
    if (!iov[0].iov_base) {
        PyErr_NoMemory();
        return NULL;
    }
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;

    msg.msg_control = &control;
    msg.msg_controllen = sizeof(control);

    ret = recvmsg(fd, &msg, flags);
    if (ret < 0) {
        PyErr_SetFromErrno(g_socketerror);
        free(iov[0].iov_base);
        return NULL;
    }

	cur=CMSG_FIRSTHDR(&msg);

	if(cur && cur->cmsg_type==SCM_CREDENTIALS && cur->cmsg_level==SOL_SOCKET)
	{
		assert(cur->cmsg_len >= sizeof(struct cmsghdr));
						// no null ancillary data messages?

		uc=(struct ucred*)CMSG_DATA(cur);
		pid=uc->pid;
		uid=uc->uid;
		gid=uc->gid;
	}

    {
        PyObject *r;
        r = Py_BuildValue("s#iii",
                iov[0].iov_base, ret,
                pid, uid, gid);
        free(iov[0].iov_base);
        return r;
    }
}
Commit	Line	Data
80d5d001 MM	1	#include <Python.h>
	2	#include <sys/types.h>
	3	#include <sys/socket.h>
	4	#include <signal.h>
	5
	6	PyObject *g_socketerror; // socket.error
	7
6ec0eee6	8	static PyObject ucred_sendcreds(PyObject self, PyObject args, PyObject keywds);
043eb941	9	static PyObject ucred_recvcreds(PyObject self, PyObject args, PyObject keywds);
80d5d001	10
6ec0eee6 MM	11	static PyMethodDef ucredMethods[] = {
6ec0eee6 MM	12	{"sendcreds", (PyCFunction)ucred_sendcreds, METH_VARARGS\|METH_KEYWORDS, NULL},
043eb941	13	{"recvcreds", (PyCFunction)ucred_recvcreds, METH_VARARGS\|METH_KEYWORDS, NULL},
80d5d001 MM	14	{NULL, NULL, 0, NULL}
	15	};
	16
6ec0eee6	17	void initucred(void) {
80d5d001	18	PyObject *module;
6ec0eee6	19	module = Py_InitModule("ucred", ucredMethods);
80d5d001	20
691ee4ea MM	21	if(-1 == PyModule_AddIntConstant(module, "SO_PASSCRED", SO_PASSCRED)) {
	22	return;
	23	}
	24
80d5d001 MM	25	module = PyImport_ImportModule("socket");
	26	if(!module) {
	27	return;
	28	}
	29	g_socketerror = PyObject_GetAttrString(module, "error");
	30	if(!g_socketerror) {
	31	return;
	32	}
	33	}
	34
6ec0eee6	35	static PyObject ucred_sendcreds(PyObject self, PyObject args, PyObject keywds) {
80d5d001	36	int fd;
80d5d001	37	int ret;
fd33b1b7	38	int pid=-1, uid=-1, gid=-1;
80d5d001 MM	39	struct msghdr msg;
80d5d001 MM	40	struct iovec iov[1];
6ec0eee6 MM	41	struct ucred uc;
	42	unsigned char control[CMSG_SPACE(sizeof(struct ucred))];
	43	struct cmsghdr *cur;
80d5d001	44
4b2ba178 MM	45	static char *kwlist[] = {"fd",
	46	"pid",
	47	"uid",
	48	"gid",
	49	NULL};
80d5d001 MM	50
80d5d001 MM	51	// kill(0, SIGTRAP);
fd33b1b7	52	if (!PyArg_ParseTupleAndKeywords(args, keywds, "i\|iii", kwlist,
4b2ba178 MM	53	&fd,
	54	&pid,
	55	&uid,
	56	&gid)) {
80d5d001 MM	57	return NULL;
	58	}
	59	// kill(0, SIGTRAP);
	60
fd33b1b7 MM	61	if(pid!=-1)
	62	uc.pid=pid;
	63	else
	64	uc.pid=getpid();
	65	if(uid!=-1)
	66	uc.uid=uid;
	67	else
	68	uc.uid=getuid();
	69	if(gid!=-1)
	70	uc.gid=gid;
	71	else
	72	uc.gid=getgid();
6ec0eee6 MM	73
	74	iov[0].iov_base="SCM_CREDENTIALS";
	75	iov[0].iov_len=15;
80d5d001	76
6ec0eee6	77	memset(&msg, 0, sizeof(msg));
80d5d001 MM	78	msg.msg_iov = iov;
80d5d001 MM	79	msg.msg_iovlen = 1;
6ec0eee6 MM	80	msg.msg_control = &control;
6ec0eee6 MM	81	msg.msg_controllen = sizeof(control);
80d5d001	82
6ec0eee6 MM	83	cur = CMSG_FIRSTHDR(&msg);
	84	cur->cmsg_level = SOL_SOCKET;
	85	cur->cmsg_type = SCM_CREDENTIALS;
	86	cur->cmsg_len = CMSG_SPACE(sizeof(struct ucred));
	87	memcpy(CMSG_DATA(cur), &uc, sizeof(struct ucred));
80d5d001	88
6ec0eee6	89	ret = sendmsg(fd, &msg, 0);
80d5d001 MM	90	if(ret < 0) {
	91	PyErr_SetFromErrno(g_socketerror);
	92	return NULL;
	93	}
	94
	95	return Py_BuildValue("i", ret);
	96	}
	97
043eb941	98	static PyObject ucred_recvcreds(PyObject self, PyObject args, PyObject keywds) {
80d5d001 MM	99	int fd;
80d5d001 MM	100	int flags=0;
043eb941 MM	101	size_t maxsize=1024;
043eb941 MM	102	char control[CMSG_SPACE(sizeof(struct ucred))];
80d5d001	103	int ret;
043eb941	104	int pid=-1, uid=-1, gid=-1;
80d5d001 MM	105	struct msghdr msg;
80d5d001 MM	106	struct iovec iov[1];
043eb941 MM	107	struct cmsghdr *cur;
	108	struct ucred *uc;
	109
80d5d001	110
043eb941	111	static char *kwlist[] = {"fd", "flags", "maxsize", NULL};
80d5d001	112
043eb941 MM	113	if (!PyArg_ParseTupleAndKeywords(args, keywds, "i\|ii", kwlist,
043eb941 MM	114	&fd, &flags, &maxsize)) {
80d5d001 MM	115	return NULL;
80d5d001 MM	116	}
80d5d001	117
043eb941	118	memset(&msg, 0, sizeof(msg));
80d5d001 MM	119
	120	iov[0].iov_len = maxsize;
	121	iov[0].iov_base = malloc(maxsize);
	122	if (!iov[0].iov_base) {
	123	PyErr_NoMemory();
	124	return NULL;
	125	}
	126	msg.msg_iov = iov;
	127	msg.msg_iovlen = 1;
	128
043eb941 MM	129	msg.msg_control = &control;
043eb941 MM	130	msg.msg_controllen = sizeof(control);
80d5d001 MM	131
	132	ret = recvmsg(fd, &msg, flags);
	133	if (ret < 0) {
	134	PyErr_SetFromErrno(g_socketerror);
	135	free(iov[0].iov_base);
80d5d001 MM	136	return NULL;
	137	}
	138
043eb941	139	cur=CMSG_FIRSTHDR(&msg);
80d5d001	140
043eb941 MM	141	if(cur && cur->cmsg_type==SCM_CREDENTIALS && cur->cmsg_level==SOL_SOCKET)
	142	{
	143	assert(cur->cmsg_len >= sizeof(struct cmsghdr));
	144	// no null ancillary data messages?
	145
	146	uc=(struct ucred*)CMSG_DATA(cur);
	147	pid=uc->pid;
	148	uid=uc->uid;
	149	gid=uc->gid;
	150	}
80d5d001 MM	151
	152	{
	153	PyObject *r;
043eb941	154	r = Py_BuildValue("s#iii",
80d5d001	155	iov[0].iov_base, ret,
043eb941	156	pid, uid, gid);
80d5d001	157	free(iov[0].iov_base);
80d5d001 MM	158	return r;
	159	}
	160	}
	161
80d5d001	162