BOOL PyObject_AsVARDESC(PyObject *ob, VARDESC *v, void *pMore)
{
	if (ob->ob_type != &PyVARDESC::Type) {
		PyErr_SetString(PyExc_TypeError, "Object is not a VARDESC.");
		return FALSE;
	}
	PyVARDESC *pyv = (PyVARDESC *)ob;
	v->memid = pyv->memid;
	v->wVarFlags = pyv->wVarFlags;
	v->varkind = (VARKIND)pyv->varkind;
	if (!PyObject_AsELEMDESC(pyv->elemdescVar, &v->elemdescVar, pMore))
		return FALSE;

	if (v->varkind == VAR_PERINSTANCE) {
		if (!PyInt_Check(pyv->value)) {
			PyErr_SetString(PyExc_TypeError, "If varkind==VAR_PERINSTANCE, value attribute must be an integer");
			return FALSE;
		}
		v->oInst = PyInt_AsLong(pyv->value);
	}  else if (v->varkind == VAR_CONST) {
		VARIANT *pVar = (VARIANT *)AllocMore(pMore, sizeof(VARIANT), TRUE);
		if (pVar==NULL) return NULL;
		VariantInit(pVar);
		if (!PyCom_VariantFromPyObject(pyv->value, pVar))
			return NULL;
		v->lpvarValue = pVar;
	}  else if (v->varkind == VAR_DISPATCH) {
		// nothing to do - memid is all that is needed by the caller.
		;
	} else {
		PyCom_LoggerWarning(NULL, "PyObject_AsVARDESC has unknown varkind (%d) - None will be used", v->varkind);
	}
	// else ignore value.
	return TRUE;
}
PyVARDESC::PyVARDESC(const VARDESC *pVD)
{
	ob_type = &PyVARDESC::Type;
	_Py_NewReference(this);

	memid = pVD->memid;
	wVarFlags = pVD->wVarFlags;
	varkind = pVD->varkind;

	if (varkind == VAR_PERINSTANCE)
		value = PyInt_FromLong(pVD->oInst);
	else if (varkind == VAR_CONST) {
		VARIANT varValue;

		// Cast the variant type here to the correct value for this constant
		// so that the correct Python type will be created below.
		// The problem seems to exist for unsigned types (the variant has
		// a signed type, but the typelib has an unsigned one).  However,
		// doing this unconditionally has side-effects, as the typelib
		// has VT_LPWSTR for the type of strings - and VariantChangeType
		// returns a VT_EMPTY variant in that case.
		// So we only perform this conversion for types known to be a problem:
		switch (pVD->elemdescVar.tdesc.vt) {
		case VT_UI1:
		case VT_UI2:
		case VT_UI4:
		case VT_UI8:
		case VT_UINT:
		case VT_UINT_PTR:
			VariantInit(&varValue);
			VariantChangeType(&varValue, pVD->lpvarValue, 0, pVD->elemdescVar.tdesc.vt);

			value  = PyCom_PyObjectFromVariant(&varValue);

			VariantClear(&varValue);
			break;
		default:
			value  = PyCom_PyObjectFromVariant(pVD->lpvarValue);
			break;
		}
	} else if (varkind == VAR_DISPATCH) {
		// all caller needs is memid, which is already setup.
		value = Py_None;
		Py_INCREF(Py_None);
	} else {
		PyCom_LoggerWarning(NULL, "PyVARDESC ctor has unknown varkind (%d) - returning None", varkind);
		value = Py_None;
		Py_INCREF(Py_None);
	}
	elemdescVar = PyObject_FromELEMDESC(&pVD->elemdescVar);
}
STDMETHODIMP PyGInternetSecurityManager::ProcessUrlAction(
		/* [in] */ LPCWSTR pwszUrl,
		/* [in] */ DWORD dwAction,
		/* [size_is][out] */ BYTE * pPolicy,
		/* [in] */ DWORD cbPolicy,
		/* [in] */ BYTE * pContext,
		/* [in] */ DWORD cbContext,
		/* [in] */ DWORD dwFlags,
		/* [in] */ DWORD dwReserved)
{
	PY_GATEWAY_METHOD;
	PyObject *obpwszUrl;
	PyObject *obContext;
	obpwszUrl = MakeOLECHARToObj(pwszUrl);
	// pContext is documented as being a GUID - but markh has seen IE
	// call this with 78 and 54 bytes in some unusual cases.  So
	// just use 'bytes' and the Python code must use magic to get a GUID.
	if (pContext==NULL) {
		obContext = Py_None;
		Py_INCREF(Py_None);
	} else
		obContext = PyString_FromStringAndSize((char *)pContext, cbContext);
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("ProcessUrlAction", &result, "OlOll", obpwszUrl, dwAction, obContext, dwFlags, dwReserved);
	Py_XDECREF(obpwszUrl);
	Py_XDECREF(obContext);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params
	if (cbPolicy==sizeof(DWORD)) {
		*((DWORD *)pPolicy) = PyInt_AsLong(result);
		if (*((DWORD *)pPolicy)==-1)
			hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("ProcessUrlAction");
	} else {
		PyCom_LoggerWarning(NULL, "PyGInternetSecurityManager::ProcessUrlAction has %d bytes for policy - what is that?", cbPolicy);
		hr = E_UNEXPECTED;
	}
	return hr;
}
Beispiel #4
0
// @doc - This file contains autoduck documentation
// ---------------------------------------------------
//
PyObject *PyObject_FromNOTIFICATION(NOTIFICATION *n)
{
	PyObject *ret = NULL;
	switch (n->ulEventType) {
		case fnevCriticalError: {
			ERROR_NOTIFICATION &err = n->info.err;
			ret = Py_BuildValue("k(s#iiN)",
					    n->ulEventType,
					    err.lpEntryID, err.cbEntryID,
					    err.scode,
					    err.ulFlags,
					    PyObject_FromMAPIERROR(err.lpMAPIError, err.ulFlags&MAPI_UNICODE, FALSE));
			break;
		}
		case fnevExtended: {
			EXTENDED_NOTIFICATION &ext = n->info.ext;
			ret = Py_BuildValue("k(ks#)", n->ulEventType, ext.ulEvent,
					    ext.pbEventParameters, ext.cb);
			break;
		}
		case fnevNewMail: {
			NEWMAIL_NOTIFICATION &newmail = n->info.newmail;
			PyObject *msg_class = newmail.ulFlags&MAPI_UNICODE?
					PyWinObject_FromWCHAR((const WCHAR *)newmail.lpszMessageClass) :
					PyString_FromString((const char *)newmail.lpszMessageClass);
			if (!msg_class)
				return NULL;
			ret = Py_BuildValue("k(s#s#kNk)",
					    n->ulEventType,
					    newmail.lpEntryID, newmail.cbEntryID,
					    newmail.lpParentID, newmail.cbParentID,
					    newmail.ulFlags,
					    msg_class,
					    newmail.ulMessageFlags);
			break;
		}
		case fnevObjectCopied:
		case fnevObjectCreated:
		case fnevObjectDeleted:
		case fnevObjectModified: 
		case fnevObjectMoved:
		case fnevSearchComplete: {
			OBJECT_NOTIFICATION &obj = n->info.obj;
			PyObject *obArray = PyMAPIObject_FromSPropTagArray(obj.lpPropTagArray);
			if (!obArray)
				return NULL;
			ret = Py_BuildValue("k(s#is#s#s#N)",
					    n->ulEventType,
					    obj.lpEntryID, obj.cbEntryID,
					    obj.ulObjType,
					    obj.lpParentID, obj.cbParentID,
					    obj.lpOldID, obj.cbOldID,
					    obj.lpOldParentID, obj.cbOldParentID,
					    obArray);
			break;
		}
		case fnevTableModified: {
			TABLE_NOTIFICATION &tab = n->info.tab;
			ret = Py_BuildValue("k(kiNNN)",
					    n->ulEventType,
					    tab.ulTableEvent,
					    tab.hResult,
					    PyMAPIObject_FromSPropValue(&tab.propIndex),
					    PyMAPIObject_FromSPropValue(&tab.propPrior),
					    PyMAPIObject_FromSRow(&tab.row));
			break;
		}
		case fnevStatusObjectModified: {
			STATUS_OBJECT_NOTIFICATION &statobj = n->info.statobj;
			ret = Py_BuildValue("k(s#N)",
					    n->ulEventType,
					    statobj.lpEntryID, statobj.cbEntryID,
					    PyMAPIObject_FromSPropValueArray(statobj.lpPropVals, statobj.cValues));
			break;
		}
		default: {
			PyCom_LoggerWarning(NULL, "unknown MAPI notification type %x", n->ulEventType);
			ret = Py_BuildValue("k(O)", n->ulEventType, Py_None);
			break;
		}
	}
	return ret;
}