/* 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, *p;

    PyObject *files;

    CCAB ccab;

    HFCI hfci;

    ERF erf;

    Py_ssize_t 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, p = cabname; *p; p = CharNext(p))

	if (*p == '\\' || *p == '/')

	    i = p - cabname + 1;

    if (i >= sizeof(ccab.szCabPath) ||

	strlen(cabname+i) >= sizeof(ccab.szCab)) {

	PyErr_SetString(PyExc_ValueError, "path name too long");

	return 0;

    }

    if (i > 0) {

	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_getinteger(msiobj* record, PyObject* args)

{

    unsigned int field;

    int status;

    if (!PyArg_ParseTuple(args, "I:GetInteger", &field))

        return NULL;

    status = MsiRecordGetInteger(record->h, field);

    if (status == MSI_NULL_INTEGER){

        PyErr_SetString(MSIError, "could not convert record field to integer");

        return NULL;

    }

    return PyInt_FromLong((long) status);

}

static PyObject*

record_getstring(msiobj* record, PyObject* args)

{

    unsigned int field;

    unsigned int status;

    char buf[2000];

    char *res = buf;

    DWORD size = sizeof(buf);

    PyObject* string;

    if (!PyArg_ParseTuple(args, "I:GetString", &field))

        return NULL;

    status = MsiRecordGetString(record->h, field, res, &size);

    if (status == ERROR_MORE_DATA) {

        res = (char*) malloc(size + 1);

        if (res == NULL)

            return PyErr_NoMemory();

        status = MsiRecordGetString(record->h, field, res, &size);

    }

    if (status != ERROR_SUCCESS)

        return msierror((int) status);

    string = PyString_FromString(res);

    if (buf != res)

        free(res);

    return string;

}

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")},

    { "GetInteger", (PyCFunction)record_getinteger, METH_VARARGS,

    PyDoc_STR("GetInteger(field) -> int\nWraps MsiRecordGetInteger")},

    { "GetString", (PyCFunction)record_getstring, METH_VARARGS,

    PyDoc_STR("GetString(field) -> string\nWraps MsiRecordGetString")},

    { "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 = {

	PyVarObject_HEAD_INIT(NULL, 0)

	"_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)

{