static int rpmfd_init(rpmfdObject *s, PyObject *args, PyObject *kwds)
{
char *kwlist[] = { "obj", "mode", "flags", NULL };
const char *mode = "r";
const char *flags = "ufdio";
char *rpmio_mode = NULL;
PyObject *fo = NULL;
FD_t fd = NULL;
int fdno;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ss", kwlist,
&fo, &mode, &flags))
return -1;
rpmio_mode = rstrscat(NULL, mode, ".", flags, NULL);
if (PyBytes_Check(fo)) {
fd = openPath(PyBytes_AsString(fo), rpmio_mode);
} else if (PyUnicode_Check(fo)) {
PyObject *enc = NULL;
int rc;
#if PY_MAJOR_VERSION >= 3
rc = PyUnicode_FSConverter(fo, &enc);
#else
rc = utf8FromPyObject(fo, &enc);
#endif
if (rc) {
fd = openPath(PyBytes_AsString(enc), rpmio_mode);
Py_DECREF(enc);
}
} else if (rpmfdObject_Check(fo)) {
rpmfdObject *fdo = (rpmfdObject *)fo;
fd = openFd(fdDup(Fileno(fdo->fd)), rpmio_mode);
} else if ((fdno = PyObject_AsFileDescriptor(fo)) >= 0) {
fd = openFd(fdDup(fdno), rpmio_mode);
} else {
PyErr_SetString(PyExc_TypeError, "path or file object expected");
}
if (fd != NULL) {
Fclose(s->fd); /* in case __init__ was called again */
free(s->mode);
free(s->flags);
s->fd = fd;
s->mode = rstrdup(mode);
s->flags = rstrdup(flags);
} else {
PyErr_SetString(PyExc_IOError, Fstrerror(fd));
}
free(rpmio_mode);
return (fd == NULL) ? -1 : 0;
}
static PyObject *
rpmts_Match(rpmtsObject * s, PyObject * args, PyObject * kwds)
{
PyObject *Key = NULL;
PyObject *str = NULL;
PyObject *mio = NULL;
char *key = NULL;
/* XXX lkey *must* be a 32 bit integer, int "works" on all known platforms. */
int lkey = 0;
int len = 0;
rpmDbiTagVal tag = RPMDBI_PACKAGES;
char * kwlist[] = {"tagNumber", "key", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O:Match", kwlist,
tagNumFromPyObject, &tag, &Key))
return NULL;
if (Key) {
if (PyInt_Check(Key)) {
lkey = PyInt_AsLong(Key);
key = (char *)&lkey;
len = sizeof(lkey);
} else if (PyLong_Check(Key)) {
lkey = PyLong_AsLong(Key);
key = (char *)&lkey;
len = sizeof(lkey);
} else if (utf8FromPyObject(Key, &str)) {
key = PyBytes_AsString(str);
len = PyBytes_Size(str);
} else {
PyErr_SetString(PyExc_TypeError, "unknown key type");
return NULL;
}
/* One of the conversions above failed, exception is set already */
if (PyErr_Occurred()) goto exit;
}
/* XXX If not already opened, open the database O_RDONLY now. */
/* XXX FIXME: lazy default rdonly open also done by rpmtsInitIterator(). */
if (rpmtsGetRdb(s->ts) == NULL) {
int rc = rpmtsOpenDB(s->ts, O_RDONLY);
if (rc || rpmtsGetRdb(s->ts) == NULL) {
PyErr_SetString(pyrpmError, "rpmdb open failed");
goto exit;
}
}
mio = rpmmi_Wrap(&rpmmi_Type, rpmtsInitIterator(s->ts, tag, key, len), (PyObject*)s);
exit:
Py_XDECREF(str);
return mio;
}
static int hdrAppendItem(Header h, rpmTagVal tag, rpmTagType type, PyObject *item)
{
int rc = 0;
switch (type) {
case RPM_I18NSTRING_TYPE: /* XXX this needs to be handled separately */
case RPM_STRING_TYPE:
case RPM_STRING_ARRAY_TYPE: {
PyObject *str = NULL;
if (utf8FromPyObject(item, &str))
rc = headerPutString(h, tag, PyBytes_AsString(str));
Py_XDECREF(str);
} break;
case RPM_BIN_TYPE: {
uint8_t *val = (uint8_t *) PyBytes_AsString(item);
rpm_count_t len = PyBytes_Size(item);
rc = headerPutBin(h, tag, val, len);
} break;
case RPM_INT64_TYPE: {
uint64_t val = PyInt_AsUnsignedLongLongMask(item);
rc = headerPutUint64(h, tag, &val, 1);
} break;
case RPM_INT32_TYPE: {
uint32_t val = PyInt_AsUnsignedLongMask(item);
rc = headerPutUint32(h, tag, &val, 1);
} break;
case RPM_INT16_TYPE: {
uint16_t val = PyInt_AsUnsignedLongMask(item);
rc = headerPutUint16(h, tag, &val, 1);
} break;
case RPM_INT8_TYPE:
case RPM_CHAR_TYPE: {
uint8_t val = PyInt_AsUnsignedLongMask(item);
rc = headerPutUint8(h, tag, &val, 1);
} break;
default:
PyErr_SetString(PyExc_TypeError, "unhandled datatype");
}
return rc;
}
int tagNumFromPyObject (PyObject *item, rpmTagVal *tagp)
{
rpmTagVal tag = RPMTAG_NOT_FOUND;
PyObject *str = NULL;
if (PyInt_Check(item)) {
/* XXX we should probably validate tag numbers too */
tag = PyInt_AsLong(item);
} else if (utf8FromPyObject(item, &str)) {
tag = rpmTagGetValue(PyBytes_AsString(str));
Py_DECREF(str);
} else {
PyErr_SetString(PyExc_TypeError, "expected a string or integer");
return 0;
}
if (tag == RPMTAG_NOT_FOUND) {
PyErr_SetString(PyExc_ValueError, "unknown header tag");
return 0;
}
*tagp = tag;
return 1;
}
