Rooba
/
cpython
mirror of https://github.com/python/cpython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cpython/PC/_msi.c

1009 lines
27 KiB
C
Raw Blame History

/* Helper library for MSI creation with Python.
* Copyright (C) 2005 Martin v. Löwis
* Licensed to PSF under a contributor agreement.
*/
#include <Python.h>
#include <fci.h>
#include <fcntl.h>
#include <windows.h>
#include <msi.h>
#include <msiquery.h>
#include <msidefs.h>
#include <rpc.h>
static PyObject *MSIError;
static PyObject*
uuidcreate(PyObject* obj, PyObject*args)
{
UUID result;
char *cresult;
PyObject *oresult;
/* May return ok, local only, and no address.
For local only, the documentation says we still get a uuid.
For RPC_S_UUID_NO_ADDRESS, it's not clear whether we can
use the result. */
if (UuidCreate(&result) == RPC_S_UUID_NO_ADDRESS) {
PyErr_SetString(PyExc_NotImplementedError, "processing 'no address' result");
return NULL;
}
if (UuidToString(&result, &cresult) == RPC_S_OUT_OF_MEMORY) {
PyErr_SetString(PyExc_MemoryError, "out of memory in uuidgen");
return NULL;
}
oresult = PyString_FromString(cresult);
RpcStringFree(&cresult);
return oresult;
}
/* FCI callback functions */
static FNFCIALLOC(cb_alloc)
{
return malloc(cb);
}
static FNFCIFREE(cb_free)
{
free(memory);
}
static FNFCIOPEN(cb_open)
{
int result = _open(pszFile, oflag, pmode);
if (result == -1)
*err = errno;
return result;
}
static FNFCIREAD(cb_read)
{
UINT result = (UINT)_read(hf, memory, cb);
if (result != cb)
*err = errno;
return result;
}
static FNFCIWRITE(cb_write)
{
UINT result = (UINT)_write(hf, memory, cb);
if (result != cb)
*err = errno;
return result;
}
static FNFCICLOSE(cb_close)
{
int result = _close(hf);
if (result != 0)
*err = errno;
return result;
}
static FNFCISEEK(cb_seek)
{
long result = (long)_lseek(hf, dist, seektype);
if (result == -1)
*err = errno;
return result;
}
static FNFCIDELETE(cb_delete)
{
int result = remove(pszFile);
if (result != 0)
*err = errno;
return result;
}
static FNFCIFILEPLACED(cb_fileplaced)
{
return 0;
}
static FNFCIGETTEMPFILE(cb_gettempfile)
{
char *name = _tempnam("", "tmp");
if ((name != NULL) && ((int)strlen(name) < cbTempName)) {
strcpy(pszTempName, name);
free(name);
return TRUE;
}
if (name) free(name);
return FALSE;
}
static FNFCISTATUS(cb_status)
{
if (pv) {
PyObject *result = PyObject_CallMethod(pv, "status", "iii", typeStatus, cb1, cb2);
if (result == NULL)
return -1;
Py_DECREF(result);
}
return 0;
}
static FNFCIGETNEXTCABINET(cb_getnextcabinet)
{
if (pv) {
PyObject *result = PyObject_CallMethod(pv, "getnextcabinet", "i", pccab->iCab);
if (result == NULL)
return -1;
if (!PyString_Check(result)) {
PyErr_Format(PyExc_TypeError,
"Incorrect return type %s from getnextcabinet",
result->ob_type->tp_name);
Py_DECREF(result);
return FALSE;
}
strncpy(pccab->szCab, PyString_AsString(result), sizeof(pccab->szCab));
return TRUE;
}
return FALSE;
}
static FNFCIGETOPENINFO(cb_getopeninfo)
{
BY_HANDLE_FILE_INFORMATION bhfi;
FILETIME filetime;
HANDLE handle;
/* Need Win32 handle to get time stamps */
handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (handle == INVALID_HANDLE_VALUE)
return -1;
if (GetFileInformationByHandle(handle, &bhfi) == FALSE)
{
CloseHandle(handle);
return -1;
}
FileTimeToLocalFileTime(&bhfi.ftLastWriteTime, &filetime);
FileTimeToDosDateTime(&filetime, pdate, ptime);
*pattribs = (int)(bhfi.dwFileAttributes &
(_A_RDONLY | _A_SYSTEM | _A_HIDDEN | _A_ARCH));
CloseHandle(handle);
return _open(pszName, _O_RDONLY | _O_BINARY);
}
static PyObject* fcicreate(PyObject* obj, PyObject* args)
{
char *cabname;
PyObject *files;
CCAB ccab;
HFCI hfci;
ERF erf;
int i;
if (!PyArg_ParseTuple(args, "sO:FCICreate", &cabname, &files))
return NULL;
if (!PyList_Check(files)) {
PyErr_SetString(PyExc_TypeError, "FCICreate expects a list");
return NULL;
}
ccab.cb = INT_MAX; /* no need to split CAB into multiple media */
ccab.cbFolderThresh = 1000000; /* flush directory after this many bytes */
ccab.cbReserveCFData = 0;
ccab.cbReserveCFFolder = 0;
ccab.cbReserveCFHeader = 0;
ccab.iCab = 1;
ccab.iDisk = 1;
ccab.setID = 0;
ccab.szDisk[0] = '\0';
for (i=0; cabname[i]; i++)
if (cabname[i] == '\\' || cabname[i] == '/')
break;
if (i > sizeof(ccab.szCabPath) ||
strlen(cabname+i) > sizeof(ccab.szCab)) {
PyErr_SetString(PyExc_ValueError, "path name too long");
return 0;
}
if (cabname[i]) {
memcpy(ccab.szCabPath, cabname, i);
ccab.szCabPath[i] = '\0';
strcpy(ccab.szCab, cabname+i);
} else {
strcpy(ccab.szCabPath, ".");
strcpy(ccab.szCab, cabname);
}
hfci = FCICreate(&erf, cb_fileplaced, cb_alloc, cb_free,
cb_open, cb_read, cb_write, cb_close, cb_seek, cb_delete,
cb_gettempfile, &ccab, NULL);
if (hfci == NULL) {
PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper);
return NULL;
}
for (i=0; i < PyList_GET_SIZE(files); i++) {
PyObject *item = PyList_GET_ITEM(files, i);
char *filename, *cabname;
if (!PyArg_ParseTuple(item, "ss", &filename, &cabname))
goto err;
if (!FCIAddFile(hfci, filename, cabname, FALSE,
cb_getnextcabinet, cb_status, cb_getopeninfo,
tcompTYPE_MSZIP))
goto err;
}
if (!FCIFlushCabinet(hfci, FALSE, cb_getnextcabinet, cb_status))
goto err;
if (!FCIDestroy(hfci))
goto err;
Py_INCREF(Py_None);
return Py_None;
err:
PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper); /* XXX better error type */
FCIDestroy(hfci);
return NULL;
}
typedef struct msiobj{
PyObject_HEAD
MSIHANDLE h;
}msiobj;
static void
msiobj_dealloc(msiobj* msidb)
{
MsiCloseHandle(msidb->h);
msidb->h = 0;
}
static PyObject*
msiobj_close(msiobj* msidb, PyObject *args)
{
MsiCloseHandle(msidb->h);
msidb->h = 0;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
msierror(int status)
{
int code;
char buf[2000];
char *res = buf;
DWORD size = sizeof(buf);
MSIHANDLE err = MsiGetLastErrorRecord();
if (err == 0) {
switch(status) {
case ERROR_ACCESS_DENIED:
PyErr_SetString(MSIError, "access denied");
return NULL;
case ERROR_FUNCTION_FAILED:
PyErr_SetString(MSIError, "function failed");
return NULL;
case ERROR_INVALID_DATA:
PyErr_SetString(MSIError, "invalid data");
return NULL;
case ERROR_INVALID_HANDLE:
PyErr_SetString(MSIError, "invalid handle");
return NULL;
case ERROR_INVALID_STATE:
PyErr_SetString(MSIError, "invalid state");
return NULL;
case ERROR_INVALID_PARAMETER:
PyErr_SetString(MSIError, "invalid parameter");
return NULL;
default:
PyErr_Format(MSIError, "unknown error %x", status);
return NULL;
}
}
code = MsiRecordGetInteger(err, 1); /* XXX code */
if (MsiFormatRecord(0, err, res, &size) == ERROR_MORE_DATA) {
res = malloc(size+1);
MsiFormatRecord(0, err, res, &size);
res[size]='\0';
}
MsiCloseHandle(err);
PyErr_SetString(MSIError, res);
if (res != buf)
free(res);
return NULL;
}
/*************************** Record objects **********************/
static PyObject*
record_getfieldcount(msiobj* record, PyObject* args)
{
return PyInt_FromLong(MsiRecordGetFieldCount(record->h));
}
static PyObject*
record_cleardata(msiobj* record, PyObject *args)
{
int status = MsiRecordClearData(record->h);
if (status != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
record_setstring(msiobj* record, PyObject *args)
{
int status;
int field;
char *data;
if (!PyArg_ParseTuple(args, "is:SetString", &field, &data))
return NULL;
if ((status = MsiRecordSetString(record->h, field, data)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
record_setstream(msiobj* record, PyObject *args)
{
int status;
int field;
char *data;
if (!PyArg_ParseTuple(args, "is:SetStream", &field, &data))
return NULL;
if ((status = MsiRecordSetStream(record->h, field, data)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
record_setinteger(msiobj* record, PyObject *args)
{
int status;
int field;
int data;
if (!PyArg_ParseTuple(args, "ii:SetInteger", &field, &data))
return NULL;
if ((status = MsiRecordSetInteger(record->h, field, data)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef record_methods[] = {
{ "GetFieldCount", (PyCFunction)record_getfieldcount, METH_NOARGS,
PyDoc_STR("GetFieldCount() -> int\nWraps MsiRecordGetFieldCount")},
{ "SetString", (PyCFunction)record_setstring, METH_VARARGS,
PyDoc_STR("SetString(field,str) -> None\nWraps MsiRecordSetString")},
{ "SetStream", (PyCFunction)record_setstream, METH_VARARGS,
PyDoc_STR("SetStream(field,filename) -> None\nWraps MsiRecordSetInteger")},
{ "SetInteger", (PyCFunction)record_setinteger, METH_VARARGS,
PyDoc_STR("SetInteger(field,int) -> None\nWraps MsiRecordSetInteger")},
{ "ClearData", (PyCFunction)record_cleardata, METH_NOARGS,
PyDoc_STR("ClearData() -> int\nWraps MsiRecordGClearData")},
{ NULL, NULL }
};
static PyTypeObject record_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"_msi.Record", /*tp_name*/
sizeof(msiobj), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)msiobj_dealloc, /*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*/
PyObject_GenericGetAttr,/*tp_getattro*/
PyObject_GenericSetAttr,/*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
record_methods, /*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*/
0, /*tp_alloc*/
0, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
};
static PyObject*
record_new(MSIHANDLE h)
{
msiobj *result = PyObject_NEW(struct msiobj, &record_Type);
if (!result) {
MsiCloseHandle(h);
return NULL;
}
result->h = h;
return (PyObject*)result;
}
/*************************** SummaryInformation objects **************/
static PyObject*
summary_getproperty(msiobj* si, PyObject *args)
{
int status;
int field;
PyObject *result;
UINT type;
INT ival;
FILETIME fval;
char sbuf[1000];
char *sval = sbuf;
DWORD ssize = sizeof(sval);
if (!PyArg_ParseTuple(args, "i:GetProperty", &field))
return NULL;
status = MsiSummaryInfoGetProperty(si->h, field, &type, &ival,
&fval, sval, &ssize);
if (status = ERROR_MORE_DATA) {
sval = malloc(ssize);
status = MsiSummaryInfoGetProperty(si->h, field, &type, &ival,
&fval, sval, &ssize);
}
switch(type) {
case VT_I2: case VT_I4:
return PyInt_FromLong(ival);
case VT_FILETIME:
PyErr_SetString(PyExc_NotImplementedError, "FILETIME result");
return NULL;
case VT_LPSTR:
result = PyString_FromStringAndSize(sval, ssize);
if (sval != sbuf)
free(sval);
return result;
}
PyErr_Format(PyExc_NotImplementedError, "result of type %d", type);
return NULL;
}
static PyObject*
summary_getpropertycount(msiobj* si, PyObject *args)
{
int status;
UINT result;
status = MsiSummaryInfoGetPropertyCount(si->h, &result);
if (status != ERROR_SUCCESS)
return msierror(status);
return PyInt_FromLong(result);
}
static PyObject*
summary_setproperty(msiobj* si, PyObject *args)
{
int status;
int field;
PyObject* data;
if (!PyArg_ParseTuple(args, "iO:SetProperty", &field, &data))
return NULL;
if (PyString_Check(data)) {
status = MsiSummaryInfoSetProperty(si->h, field, VT_LPSTR,
0, NULL, PyString_AsString(data));
} else if (PyInt_Check(data)) {
status = MsiSummaryInfoSetProperty(si->h, field, VT_I4,
PyInt_AsLong(data), NULL, NULL);
} else {
PyErr_SetString(PyExc_TypeError, "unsupported type");
return NULL;
}
if (status != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
summary_persist(msiobj* si, PyObject *args)
{
int status;
status = MsiSummaryInfoPersist(si->h);
if (status != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef summary_methods[] = {
{ "GetProperty", (PyCFunction)summary_getproperty, METH_VARARGS,
PyDoc_STR("GetProperty(propid) -> value\nWraps MsiSummaryInfoGetProperty")},
{ "GetPropertyCount", (PyCFunction)summary_getpropertycount, METH_NOARGS,
PyDoc_STR("GetProperty() -> int\nWraps MsiSummaryInfoGetPropertyCount")},
{ "SetProperty", (PyCFunction)summary_setproperty, METH_VARARGS,
PyDoc_STR("SetProperty(value) -> None\nWraps MsiSummaryInfoProperty")},
{ "Persist", (PyCFunction)summary_persist, METH_NOARGS,
PyDoc_STR("Persist() -> None\nWraps MsiSummaryInfoPersist")},
{ NULL, NULL }
};
static PyTypeObject summary_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"_msi.SummaryInformation", /*tp_name*/
sizeof(msiobj), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)msiobj_dealloc, /*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*/
PyObject_GenericGetAttr,/*tp_getattro*/
PyObject_GenericSetAttr,/*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
summary_methods, /*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*/
0, /*tp_alloc*/
0, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
};
/*************************** View objects **************/
static PyObject*
view_execute(msiobj *view, PyObject*args)
{
int status;
MSIHANDLE params = 0;
PyObject *oparams = Py_None;
if (!PyArg_ParseTuple(args, "O:Execute", &oparams))
return NULL;
if (oparams != Py_None) {
if (oparams->ob_type != &record_Type) {
PyErr_SetString(PyExc_TypeError, "Execute argument must be a record");
return NULL;
}
params = ((msiobj*)oparams)->h;
}
status = MsiViewExecute(view->h, params);
if (status != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
view_fetch(msiobj *view, PyObject*args)
{
int status;
MSIHANDLE result;
if ((status = MsiViewFetch(view->h, &result)) != ERROR_SUCCESS)
return msierror(status);
return record_new(result);
}
static PyObject*
view_getcolumninfo(msiobj *view, PyObject *args)
{
int status;
int kind;
MSIHANDLE result;
if (!PyArg_ParseTuple(args, "i:GetColumnInfo", &kind))
return NULL;
if ((status = MsiViewGetColumnInfo(view->h, kind, &result)) != ERROR_SUCCESS)
return msierror(status);
return record_new(result);
}
static PyObject*
view_modify(msiobj *view, PyObject *args)
{
int kind;
PyObject *data;
int status;
if (!PyArg_ParseTuple(args, "iO:Modify", &kind, &data))
return NULL;
if (data->ob_type != &record_Type) {
PyErr_SetString(PyExc_TypeError, "Modify expects a record object");
return NULL;
}
if ((status = MsiViewModify(view->h, kind, ((msiobj*)data)->h)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
view_close(msiobj *view, PyObject*args)
{
int status;
if ((status = MsiViewClose(view->h)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef view_methods[] = {
{ "Execute", (PyCFunction)view_execute, METH_VARARGS,
PyDoc_STR("Execute(params=None) -> None\nWraps MsiViewExecute")},
{ "GetColumnInfo", (PyCFunction)view_getcolumninfo, METH_VARARGS,
PyDoc_STR("GetColumnInfo() -> result\nWraps MsiGetColumnInfo")},
{ "Fetch", (PyCFunction)view_fetch, METH_NOARGS,
PyDoc_STR("Fetch() -> result\nWraps MsiViewFetch")},
{ "Modify", (PyCFunction)view_modify, METH_VARARGS,
PyDoc_STR("Modify(mode,record) -> None\nWraps MsiViewModify")},
{ "Close", (PyCFunction)view_close, METH_NOARGS,
PyDoc_STR("Close() -> result\nWraps MsiViewClose")},
{ NULL, NULL }
};
static PyTypeObject msiview_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"_msi.View", /*tp_name*/
sizeof(msiobj), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)msiobj_dealloc, /*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*/
PyObject_GenericGetAttr,/*tp_getattro*/
PyObject_GenericSetAttr,/*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
view_methods, /*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*/
0, /*tp_alloc*/
0, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
};
/*************************** Database objects **************/
static PyObject*
msidb_openview(msiobj *msidb, PyObject *args)
{
int status;
char *sql;
MSIHANDLE hView;
msiobj *result;
if (!PyArg_ParseTuple(args, "s:OpenView", &sql))
return NULL;
if ((status = MsiDatabaseOpenView(msidb->h, sql, &hView)) != ERROR_SUCCESS)
return msierror(status);
result = PyObject_NEW(struct msiobj, &msiview_Type);
if (!result) {
MsiCloseHandle(hView);
return NULL;
}
result->h = hView;
return (PyObject*)result;
}
static PyObject*
msidb_commit(msiobj *msidb, PyObject *args)
{
int status;
if ((status = MsiDatabaseCommit(msidb->h)) != ERROR_SUCCESS)
return msierror(status);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject*
msidb_getsummaryinformation(msiobj *db, PyObject *args)
{
int status;
int count;
MSIHANDLE result;
msiobj *oresult;
if (!PyArg_ParseTuple(args, "i:GetSummaryInformation", &count))
return NULL;
status = MsiGetSummaryInformation(db->h, NULL, count, &result);
if (status != ERROR_SUCCESS)
return msierror(status);
oresult = PyObject_NEW(struct msiobj, &summary_Type);
if (!result) {
MsiCloseHandle(result);
return NULL;
}
oresult->h = result;
return (PyObject*)oresult;
}
static PyMethodDef db_methods[] = {
{ "OpenView", (PyCFunction)msidb_openview, METH_VARARGS,
PyDoc_STR("OpenView(sql) -> viewobj\nWraps MsiDatabaseOpenView")},
{ "Commit", (PyCFunction)msidb_commit, METH_NOARGS,
PyDoc_STR("Commit() -> None\nWraps MsiDatabaseCommit")},
{ "GetSummaryInformation", (PyCFunction)msidb_getsummaryinformation, METH_VARARGS,
PyDoc_STR("GetSummaryInformation(updateCount) -> viewobj\nWraps MsiGetSummaryInformation")},
{ NULL, NULL }
};
static PyTypeObject msidb_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"_msi.Database", /*tp_name*/
sizeof(msiobj), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)msiobj_dealloc, /*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*/
PyObject_GenericGetAttr,/*tp_getattro*/
PyObject_GenericSetAttr,/*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
0, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
db_methods, /*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*/
0, /*tp_alloc*/
0, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
};
static PyObject* msiopendb(PyObject *obj, PyObject *args)
{
int status;
char *path;
int persist;
MSIHANDLE h;
msiobj *result;
if (!PyArg_ParseTuple(args, "si:MSIOpenDatabase", &path, &persist))
return NULL;
status = MsiOpenDatabase(path, (LPCSTR)persist, &h);
if (status != ERROR_SUCCESS)
return msierror(status);
result = PyObject_NEW(struct msiobj, &msidb_Type);
if (!result) {
MsiCloseHandle(h);
return NULL;
}
result->h = h;
return (PyObject*)result;
}
static PyObject*
createrecord(PyObject *o, PyObject *args)
{
int count;
MSIHANDLE h;
if (!PyArg_ParseTuple(args, "i:CreateRecord", &count))
return NULL;
h = MsiCreateRecord(count);
if (h == 0)
return msierror(0);
return record_new(h);
}
static PyMethodDef msi_methods[] = {
{"UuidCreate", (PyCFunction)uuidcreate, METH_NOARGS,
PyDoc_STR("UuidCreate() -> string")},
{"FCICreate", (PyCFunction)fcicreate, METH_VARARGS,
PyDoc_STR("fcicreate(cabname,files) -> None")},
{"OpenDatabase", (PyCFunction)msiopendb, METH_VARARGS,
PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiOpenDatabase")},
{"CreateRecord", (PyCFunction)createrecord, METH_VARARGS,
PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiCreateRecord")},
{NULL, NULL} /* sentinel */
};
static char msi_doc[] = "Documentation";
PyMODINIT_FUNC
init_msi(void)
{
PyObject *m;
m = Py_InitModule3("_msi", msi_methods, msi_doc);
if (m == NULL)
return;
PyModule_AddIntConstant(m, "MSIDBOPEN_CREATEDIRECT", (int)MSIDBOPEN_CREATEDIRECT);
PyModule_AddIntConstant(m, "MSIDBOPEN_CREATE", (int)MSIDBOPEN_CREATE);
PyModule_AddIntConstant(m, "MSIDBOPEN_DIRECT", (int)MSIDBOPEN_DIRECT);
PyModule_AddIntConstant(m, "MSIDBOPEN_READONLY", (int)MSIDBOPEN_READONLY);
PyModule_AddIntConstant(m, "MSIDBOPEN_TRANSACT", (int)MSIDBOPEN_TRANSACT);
PyModule_AddIntConstant(m, "MSIDBOPEN_PATCHFILE", (int)MSIDBOPEN_PATCHFILE);
PyModule_AddIntConstant(m, "MSICOLINFO_NAMES", MSICOLINFO_NAMES);
PyModule_AddIntConstant(m, "MSICOLINFO_TYPES", MSICOLINFO_TYPES);
PyModule_AddIntConstant(m, "MSIMODIFY_SEEK", MSIMODIFY_SEEK);
PyModule_AddIntConstant(m, "MSIMODIFY_REFRESH", MSIMODIFY_REFRESH);
PyModule_AddIntConstant(m, "MSIMODIFY_INSERT", MSIMODIFY_INSERT);
PyModule_AddIntConstant(m, "MSIMODIFY_UPDATE", MSIMODIFY_UPDATE);
PyModule_AddIntConstant(m, "MSIMODIFY_ASSIGN", MSIMODIFY_ASSIGN);
PyModule_AddIntConstant(m, "MSIMODIFY_REPLACE", MSIMODIFY_REPLACE);
PyModule_AddIntConstant(m, "MSIMODIFY_MERGE", MSIMODIFY_MERGE);
PyModule_AddIntConstant(m, "MSIMODIFY_DELETE", MSIMODIFY_DELETE);
PyModule_AddIntConstant(m, "MSIMODIFY_INSERT_TEMPORARY", MSIMODIFY_INSERT_TEMPORARY);
PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE", MSIMODIFY_VALIDATE);
PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_NEW", MSIMODIFY_VALIDATE_NEW);
PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_FIELD", MSIMODIFY_VALIDATE_FIELD);
PyModule_AddIntConstant(m, "MSIMODIFY_VALIDATE_DELETE", MSIMODIFY_VALIDATE_DELETE);
PyModule_AddIntConstant(m, "PID_CODEPAGE", PID_CODEPAGE);
PyModule_AddIntConstant(m, "PID_TITLE", PID_TITLE);
PyModule_AddIntConstant(m, "PID_SUBJECT", PID_SUBJECT);
PyModule_AddIntConstant(m, "PID_AUTHOR", PID_AUTHOR);
PyModule_AddIntConstant(m, "PID_KEYWORDS", PID_KEYWORDS);
PyModule_AddIntConstant(m, "PID_COMMENTS", PID_COMMENTS);
PyModule_AddIntConstant(m, "PID_TEMPLATE", PID_TEMPLATE);
PyModule_AddIntConstant(m, "PID_LASTAUTHOR", PID_LASTAUTHOR);
PyModule_AddIntConstant(m, "PID_REVNUMBER", PID_REVNUMBER);
PyModule_AddIntConstant(m, "PID_LASTPRINTED", PID_LASTPRINTED);
PyModule_AddIntConstant(m, "PID_CREATE_DTM", PID_CREATE_DTM);
PyModule_AddIntConstant(m, "PID_LASTSAVE_DTM", PID_LASTSAVE_DTM);
PyModule_AddIntConstant(m, "PID_PAGECOUNT", PID_PAGECOUNT);
PyModule_AddIntConstant(m, "PID_WORDCOUNT", PID_WORDCOUNT);
PyModule_AddIntConstant(m, "PID_CHARCOUNT", PID_CHARCOUNT);
PyModule_AddIntConstant(m, "PID_APPNAME", PID_APPNAME);
PyModule_AddIntConstant(m, "PID_SECURITY", PID_SECURITY);
MSIError = PyErr_NewException ("_msi.MSIError", NULL, NULL);
if (!MSIError)
return;
PyModule_AddObject(m, "MSIError", MSIError);
}
Reference in New Issue View Git Blame Copy Permalink