@@@ remove debugging print

[mLib-python] / sys.c

/* -*-c-*-
 *
 * System-specific functionality
 *
 * (c) 2019 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Python interface to mLib.
 *
 * mLib/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.
 *
 * mLib/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 mLib/Python.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

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

#include "mLib-python.h"

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

static int getint(PyObject *obj, int *i_out)
{
  PyObject *t = 0;
  long i;
  int rc = -1;

  t = PyNumber_Index(obj); if (!t) goto end;
  i = PyInt_AsLong(t); if (i == -1 && PyErr_Occurred()) goto end;
  if (INT_MIN > i || i > INT_MAX) OVFERR("out of range");
  *i_out = i;
  rc = 0;
end:
  Py_XDECREF(t);
  return (rc);
}

static int convfd(PyObject *obj, void *p)
{
  int *fd_out = p;
  PyObject *t = 0;
  int rc = 0;

  if (getint(obj, fd_out)) {
    PyErr_Clear();
    t = PyObject_CallMethod(obj, "fileno", 0); if (!t) goto end;
    if (getint(t, fd_out)) goto end;
  }
  rc = 1;
end:
  Py_XDECREF(t);
  return (rc);
}

static PyObject *meth_detachtty(PyObject *me)
  { detachtty(); RETURN_NONE; }

static PyObject *meth_daemonize(PyObject *me)
{
  if (daemonize()) OSERR(0);
  RETURN_NONE;
end:
  return (0);
}

static PyObject *meth_fdflags(PyObject *me, PyObject *arg, PyObject *kw)
{
  int fd;
  unsigned fbic = 0, fxor = 0, fdbic = 0, fdxor = 0;
  static const char *const kwlist[] =
    { "file", "fbic", "fxor", "fdbic", "fdxor", 0 };

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&O&O&O&:fdflags", KWLIST,
				   convfd, &fd,
				   convuint, &fbic, convuint, &fxor,
				   convuint, &fdbic, convuint, &fdxor))
    goto end;
  if (fdflags(fd, fbic, fxor, fdbic, fdxor)) OSERR(0);
  RETURN_NONE;
end:
  return (0);
}

static PyObject *meth_fdsend(PyObject *me, PyObject *arg, PyObject *kw)
{
  int sock, fd;
  struct bin buf;
  ssize_t n;
  PyObject *rc = 0;
  static const char *const kwlist[] = { "sock", "file", "buffer", 0 };

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&O&:fdsend", KWLIST,
				   convfd, &sock, convfd, &fd,
				   convbin, &buf))
    goto end;
  n = fdpass_send(sock, fd, buf.p, buf.sz); if (n < 0) OSERR(0);
  rc = PyInt_FromLong(n);
end:
  return (rc);
}

static PyObject *meth_fdrecv(PyObject *me, PyObject *arg, PyObject *kw)
{
  int sock, fd;
  size_t sz;
  ssize_t n;
  void *p;
  PyObject *buf = 0, *rc = 0;
  static const char *const kwlist[] = { "sock", "size", 0 };

  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:fdrecv", KWLIST,
				   convfd, &sock, convszt, &sz))
    goto end;
  BIN_PREPAREWRITE(buf, p, sz);
  n = fdpass_recv(sock, &fd, p, sz); if (n < 0) OSERR(0);
  BIN_DONEWRITE(buf, n);
  rc = Py_BuildValue("(iN)", fd, buf); buf = 0;
end:
  Py_XDECREF(buf);
  return (rc);
}

static PyObject *meth_mdup(PyObject *me, PyObject *arg)
{
  PyObject *v;
  PyObject *t = 0, *u = 0, *rc = 0;
  Py_ssize_t n, m;
  mdup_fd *vv;
  size_t i;
  int err;

  if (!PyArg_ParseTuple(arg, "O:mdup", &v)) goto end;
  n = PySequence_Size(v); if (n < 0) goto end;
  vv = xmalloc(n*sizeof(*vv));
  for (i = 0; i < n; i++) {
    t = PySequence_GetItem(v, i); if (!t) goto end;
    m = PySequence_Size(t); if (m < 0) goto end;
    if (m != 2) VALERR("expected a list of pairs");

    u = PySequence_GetItem(t, 0);
    if (getint(u, &vv[i].cur)) goto end;
    Py_DECREF(u); u = 0;

    u = PySequence_GetItem(t, 1);
    if (getint(u, &vv[i].want)) goto end;
    Py_DECREF(u); u = 0;

    Py_DECREF(t); t = 0;
  }

  err = mdup(vv, n);

  for (i = 0; i < n; i++) {
    t = Py_BuildValue("(ii)", vv[i].cur, vv[i].want);
    if (PySequence_SetItem(v, i, t)) goto end;
    Py_DECREF(t); t = 0;
  }

  if (err) OSERR(0);
  rc = v; Py_INCREF(rc);

end:
  Py_XDECREF(t); Py_XDECREF(u);
  return (rc);
}

static const PyMethodDef methods[] = {
#define METHNAME(name) meth_##name
  NAMETH(detachtty,	"detachtty(): fork, detatch controlling terminal")
  NAMETH(daemonize,	"daemonize(): fork and become a daemon")
  KWMETH(fdflags,	"fdflags(FILE, [fbic = 0], [fxor = 0], "
						 "[fdbic = 0], [fdxor = 0])")
  KWMETH(fdsend,	"fdsend(FILE, FD, BUFFER) -> N")
  KWMETH(fdrecv,	"fdrecv(FILE, SIZE) -> FD, BUFFER")
  METH	(mdup,		"mdup(LIST) -> LIST:\n"
    "  LIST is a list (mutable sequence) of pairs (CUR, WANT).  Duplicate\n"
    "  each CUR file descriptor as WANT (may be -1 to mean `don't care'),\n"
    "  closing original CUR.  Works even if there are cycles.  LIST is\n"
    "  updated in place with CUR reflecting the new file descriptors even\n"
    "  on error.  Returns the same LIST on success.")
#undef METHNAME
  { 0 }
};

void sys_pyinit(void)
{
  addmethods(methods);
}

void sys_pyinsert(PyObject *mod)
{
}

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