int
mu_iostream_create (mu_stream_t *pref, mu_stream_t in, mu_stream_t out)
{
struct _mu_iostream *sp;
sp = (struct _mu_iostream *)
_mu_stream_create (sizeof (*sp),
MU_STREAM_READ | MU_STREAM_WRITE);
if (!sp)
return ENOMEM;
sp->stream.flags |= _MU_STR_OPEN;
sp->stream.read = _iostream_read;
if (in->readdelim)
sp->stream.readdelim = _iostream_readdelim;
sp->stream.write = _iostream_write;
sp->stream.flush = _iostream_flush;
sp->stream.open = _iostream_open;
sp->stream.close = _iostream_close;
sp->stream.done = _iostream_done;
sp->stream.ctl = _iostream_ctl;
sp->stream.wait = _iostream_wait;
sp->stream.shutdown = _iostream_shutdown;
sp->stream.error_string = _iostream_error_string;
mu_stream_ref (in);
sp->transport[_MU_STREAM_INPUT] = in;
mu_stream_ref (out);
sp->transport[_MU_STREAM_OUTPUT] = out;
mu_stream_set_buffer ((mu_stream_t) sp, mu_buffer_line, 0);
*pref = (mu_stream_t) sp;
return 0;
}
static PyObject *
api_stream_ref (PyObject *self, PyObject *args)
{
PyStream *py_stm;
if (!PyArg_ParseTuple (args, "O!", &PyStreamType, &py_stm))
return NULL;
mu_stream_ref (py_stm->stm);
return _ro (Py_None);
}
int
mu_streamref_create_abridged (mu_stream_t *pref, mu_stream_t str,
mu_off_t start, mu_off_t end)
{
int rc;
mu_off_t off;
int flags;
struct _mu_streamref *sp;
rc = mu_stream_seek (str, 0, MU_SEEK_SET, &off);/*FIXME: SEEK_CUR?*/
if (rc)
return rc;
mu_stream_get_flags (str, &flags);
sp = (struct _mu_streamref *)
_mu_stream_create (sizeof (*sp), flags | _MU_STR_OPEN);
if (!sp)
return ENOMEM;
mu_stream_ref (str);
sp->stream.read = _streamref_read;
if (str->readdelim)
sp->stream.readdelim = _streamref_readdelim;
sp->stream.write = _streamref_write;
sp->stream.flush = _streamref_flush;
sp->stream.open = _streamref_open;
sp->stream.close = _streamref_close;
sp->stream.done = _streamref_done;
sp->stream.seek = _streamref_seek;
sp->stream.size = _streamref_size;
sp->stream.ctl = _streamref_ctl;
sp->stream.wait = _streamref_wait;
sp->stream.truncate = _streamref_truncate;
sp->stream.shutdown = _streamref_shutdown;
sp->stream.error_string = _streamref_error_string;
sp->transport = str;
sp->start = start;
sp->end = end;
if (off < start || off > end)
off = start;
sp->offset = off;
*pref = (mu_stream_t) sp;
mu_stream_set_buffer (*pref, mu_buffer_full, 0);
return 0;
}
static void
_sieve_action_printer (void *data, mu_stream_t stream,
size_t msgno, mu_message_t msg,
const char *action, const char *fmt, va_list ap)
{
PyObject *py_args;
PyObject *py_dict = PyDict_New ();
PyStream *py_stm;
if (!py_dict)
return;
py_stm = PyStream_NEW ();
if (py_stm)
{
PyMessage *py_msg = PyMessage_NEW ();
char *buf = NULL;
size_t buflen = 0;
if (py_msg)
{
PyStream *py_stm = PyStream_NEW ();
if (py_stm)
{
py_stm->stm = stream;
mu_stream_ref (stream);
py_msg->msg = msg;
Py_INCREF (py_msg);
PyDict_SetItemString (py_dict, "msgno",
PyInt_FromSize_t (msgno));
PyDict_SetItemString (py_dict, "msg", (PyObject *)py_msg);
PyDict_SetItemString (py_dict, "action",
PyString_FromString (action ? action : ""));
if (mu_vasnprintf (&buf, &buflen, fmt, ap))
{
mu_stream_unref (stream);
return;
}
PyDict_SetItemString (py_dict, "text",
PyString_FromString (buf ? buf : ""));
free (buf);
py_args = PyTuple_New (1);
if (py_args)
{
struct _mu_py_sieve_logger *s = data;
PyObject *py_fnc = s->py_action_printer;
Py_INCREF (py_dict);
PyTuple_SetItem (py_args, 0, py_dict);
if (py_fnc && PyCallable_Check (py_fnc))
PyObject_CallObject (py_fnc, py_args);
Py_DECREF (py_dict);
Py_DECREF (py_args);
}
}
}
}
}
static int
_iostream_ctl (struct _mu_stream *str, int code, int opcode, void *arg)
{
struct _mu_iostream *sp = (struct _mu_iostream *)str;
switch (code)
{
case MU_IOCTL_TRANSPORT:
if (!arg)
return EINVAL;
else
{
mu_transport_t *ptrans = arg;
switch (opcode)
{
case MU_IOCTL_OP_GET:
ptrans[0] = (mu_transport_t) sp->transport[_MU_STREAM_INPUT];
ptrans[1] = (mu_transport_t) sp->transport[_MU_STREAM_OUTPUT];
break;
case MU_IOCTL_OP_SET:
ptrans = arg;
sp->transport[_MU_STREAM_INPUT] = (mu_stream_t) ptrans[0];
sp->transport[_MU_STREAM_OUTPUT] = (mu_stream_t) ptrans[1];
break;
default:
return EINVAL;
}
}
break;
case MU_IOCTL_SUBSTREAM:
case MU_IOCTL_TOPSTREAM:
if (!arg)
return EINVAL;
else
{
mu_stream_t *pstr = arg;
switch (opcode)
{
case MU_IOCTL_OP_GET:
pstr[0] = sp->transport[0];
mu_stream_ref (pstr[0]);
pstr[1] = sp->transport[1];
mu_stream_ref (pstr[1]);
break;
case MU_IOCTL_OP_SET:
mu_stream_unref (sp->transport[0]);
sp->transport[0] = pstr[0];
mu_stream_ref (sp->transport[0]);
mu_stream_unref (sp->transport[1]);
sp->transport[1] = pstr[1];
mu_stream_ref (sp->transport[1]);
break;
default:
return EINVAL;
}
}
break;
case MU_IOCTL_TRANSPORT_BUFFER:
if (!arg)
return EINVAL;
else
{
struct mu_buffer_query *qp = arg;
if (!MU_TRANSPORT_VALID_TYPE (qp->type) || !sp->transport[qp->type])
return EINVAL;
return mu_stream_ioctl (sp->transport[qp->type], code, opcode, arg);
}
default:
return ENOSYS;
}
return 0;
}
int
mutool_filter (int argc, char **argv)
{
int rc, index;
mu_stream_t flt, prev_stream;
const char *fltname;
int mode;
if (argp_parse (&filter_argp, argc, argv, ARGP_IN_ORDER, &index, NULL))
return 1;
argc -= index;
argv += index;
if (list_option)
{
if (argc)
{
mu_error (_("excess arguments"));
return 1;
}
return list_filters ();
}
if (argc == 0)
{
mu_error (_("what filter do you want?"));
return 1;
}
prev_stream = mu_strin;
mu_stream_ref (mu_strin);
do
{
int i;
fltname = argv[0];
if (fltname[0] == '~')
{
mode = negate_filter_mode (filter_mode);
fltname++;
}
else
mode = filter_mode;
for (i = 1; i < argc; i++)
if (strcmp (argv[i], "+") == 0)
break;
rc = mu_filter_create_args (&flt, prev_stream, fltname,
i, (const char **)argv,
mode, MU_STREAM_READ);
mu_stream_unref (prev_stream);
if (rc)
{
mu_error (_("cannot open filter stream: %s"), mu_strerror (rc));
return 1;
}
prev_stream = flt;
argc -= i;
argv += i;
if (argc)
{
argc--;
argv++;
}
}
while (argc);
rc = mu_stream_copy (mu_strout, flt, 0, NULL);
if (rc)
{
mu_error ("%s", mu_strerror (rc));
return 1;
}
if (newline_option)
mu_stream_write (mu_strout, "\n", 1, NULL);
mu_stream_destroy (&flt);
mu_stream_flush (mu_strout);
return 0;
}