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; }