Initial check-in of catacomb-python.

[catacomb-python] / passphrase.c

/* -*-c-*-
 *
 * $Id$
 *
 * Reading and writing passphrases
 *
 * (c) 2005 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the Python interface to Catacomb.
 *
 * Catacomb/Python is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Catacomb/Python is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Catacomb/Python; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "catacomb-python.h"

/*----- Pixie stuff -------------------------------------------------------*/

typedef struct pixie_pyobj {
  PyObject_HEAD
  int fd;
} pixie_pyobj;

static PyTypeObject *pixie_pytype;
#define PIXIE_PYCHECK(o) PyObject_TypeCheck((o), pixie_pytype)
#define PIXIE_FD(o) (((pixie_pyobj *)(o))->fd)

static int convpixie(PyObject *o, void *p)
{
  if (!PIXIE_PYCHECK(o))
    TYERR("want pixie");
  *(int *)p = PIXIE_FD(o);
  return (1);
end:
  return (0);
}

static PyObject *pixie_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
  pixie_pyobj *rc = 0;
  char *kwlist[] = { "socket", 0 };
  char *sock = 0;
  int fd;

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "|s:new", kwlist, &sock))
    goto end;
  if ((fd = pixie_open(sock)) < 0)
    OSERR(sock);
  rc = (pixie_pyobj *)ty->tp_alloc(ty, 0);
  rc->fd = fd;
end:
  return ((PyObject *)rc);
}

static void pixie_pydealloc(PyObject *me)
{
  close(PIXIE_FD(me));
  PyObject_DEL(me);
  
}

static PyObject *pixmeth_read(PyObject *me, PyObject *arg, PyObject *kw)
{
  unsigned mode = PMODE_READ;
  char *tag;
  char *kwlist[] = { "tag", "mode", 0 };
  PyObject *rc = 0;
  int r;
  char buf[1024];

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:read", kwlist,
				   &tag, convuint, &mode))
    goto end;
  r = pixie_read(PIXIE_FD(me), tag, mode, buf, sizeof(buf));
  if (r < 0)
    OSERR(0);
  else if (r > 0)
    RETURN_NONE;
  else
    rc = PyString_FromString(buf);
end:
  return (rc);
}

static PyObject *pixmeth_set(PyObject *me, PyObject *arg)
{
  char *tag;
  char *phrase;

  if (!PyArg_ParseTuple(arg, "ss:set", &tag, &phrase))
    return (0);
  pixie_set(PIXIE_FD(me), tag, phrase);
  RETURN_ME;
}

static PyObject *pixmeth_cancel(PyObject *me, PyObject *arg)
{
  char *tag;

  if (!PyArg_ParseTuple(arg, "s:cancel", &tag))
    return (0);
  pixie_cancel(PIXIE_FD(me), tag);
  RETURN_ME;
}

static PyMethodDef pixie_pymethods[] = {
#define METHNAME(name) pixmeth_##name
  KWMETH(read,		"P.read(TAG, [mode = PMODE_READ]) -> STRING")
  METH	(set,		"P.set(TAG, PHRASE)")
  METH	(cancel,	"P.cancel(TAG)")
#undef METHNAME
  { 0 }
};

static PyTypeObject pixie_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.Pixie",			/* @tp_name@ */
  sizeof(pixie_pyobj),			/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  pixie_pydealloc,			/* @tp_dealloc@ */
  0,					/* @tp_print@ */
  0,					/* @tp_getattr@ */
  0,					/* @tp_setattr@ */
  0,					/* @tp_compare@ */
  0,					/* @tp_repr@ */
  0,					/* @tp_as_number@ */
  0,					/* @tp_as_sequence@ */
  0,					/* @tp_as_mapping@ */
  0,					/* @tp_hash@ */
  0,					/* @tp_call@ */
  0,					/* @tp_str@ */
  0,					/* @tp_getattro@ */
  0,					/* @tp_setattro@ */
  0,					/* @tp_as_buffer@ */
  Py_TPFLAGS_DEFAULT |			/* @tp_flags@ */
    Py_TPFLAGS_BASETYPE,

  /* @tp_doc@ */
"Passphrase pixie connection.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  pixie_pymethods,			/* @tp_methods@ */
  0,					/* @tp_members@ */
  0,					/* @tp_getset@ */
  0,					/* @tp_base@ */
  0,					/* @tp_dict@ */
  0,					/* @tp_descr_get@ */
  0,					/* @tp_descr_set@ */
  0,					/* @tp_dictoffset@ */
  0,					/* @tp_init@ */
  PyType_GenericAlloc,			/* @tp_alloc@ */
  pixie_pynew,				/* @tp_new@ */
  _PyObject_Del,			/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

/*----- Main code ---------------------------------------------------------*/

static PyObject *meth_ppread(PyObject *me, PyObject *arg, PyObject *kw)
{
  char *tag;
  unsigned f = PMODE_READ;
  PyObject *rc = 0;
  char *kwlist[] = { "tag", "mode", 0 };
  char buf[1024];

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:ppread", kwlist,
				   &tag, convuint, &f))
    goto end;
  if (passphrase_read(tag, f, buf, sizeof(buf)))
    SYSERR("passphrase read failed");
  rc = PyString_FromString(buf);
end:
  return (rc);
}

static PyObject *meth_ppcancel(PyObject *me, PyObject *arg)
{
  char *tag;

  if (!PyArg_ParseTuple(arg, "s:ppcancel", &tag))
    return (0);
  passphrase_cancel(tag);
  RETURN_NONE;
}

static PyObject *meth_getpass(PyObject *me, PyObject *arg)
{
  char *prompt;
  char buf[1024];
  PyObject *rc = 0;

  if (!PyArg_ParseTuple(arg, "s:getpass", &prompt))
    goto end;
  if (pixie_getpass(prompt, buf, sizeof(buf)))
    OSERR(0);
  rc = PyString_FromString(buf);
end:
  return (rc);
}

static PyMethodDef methods[] = {
#define METHNAME(name) meth_##name
  KWMETH(ppread,		"ppread(TAG, [mode = PMODE_READ]) -> STRING")
  METH	(ppcancel,		"ppcancel(TAG)")
  METH	(getpass,		"getpass(PROMPT) -> STRING")
#undef METHNAME
  { 0 }
};

void passphrase_pyinit(void)
{
  INITTYPE(pixie, root);
  addmethods(methods);
}

void passphrase_pyinsert(PyObject *mod)
{
  INSERT("Pixie", pixie_pytype);
}

/*----- That's all, folks -------------------------------------------------*/