/*
* Initial load of the Python module.
*
* Based on the parsed plugin options we set some prerequisits like the
* module path and the module to load. We also load the dictionary used
* for looking up the Python methods.
*/
static bRC PyLoadModule(bpContext *ctx, void *value)
{
bRC retval = bRC_Error;
struct plugin_ctx *p_ctx = (struct plugin_ctx *)ctx->pContext;
PyObject *sysPath,
*mPath,
*pName,
*pFunc,
*module;
/*
* Extend the Python search path with the given module_path.
*/
if (p_ctx->module_path) {
sysPath = PySys_GetObject((char *)"path");
mPath = PyString_FromString(p_ctx->module_path);
PyList_Append(sysPath, mPath);
Py_DECREF(mPath);
}
/*
* Make our callback methods available for Python.
*/
module = Py_InitModule("bareossd", BareosSDMethods);
/*
* Try to load the Python module by name.
*/
if (p_ctx->module_name) {
Dmsg(ctx, dbglvl, "Trying to load module with name %s\n", p_ctx->module_name);
pName = PyString_FromString(p_ctx->module_name);
p_ctx->pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (!p_ctx->pModule) {
Dmsg(ctx, dbglvl, "Failed to load module with name %s\n", p_ctx->module_name);
goto bail_out;
}
Dmsg(ctx, dbglvl, "Successfully loaded module with name %s\n", p_ctx->module_name);
/*
* Get the Python dictionary for lookups in the Python namespace.
*/
p_ctx->pDict = PyModule_GetDict(p_ctx->pModule); /* Borrowed reference */
/*
* Encode the bpContext so a Python method can pass it in on calling back.
*/
p_ctx->bpContext = PyCreatebpContext(ctx);
/*
* Lookup the load_bareos_plugin() function in the python module.
*/
pFunc = PyDict_GetItemString(p_ctx->pDict, "load_bareos_plugin"); /* Borrowed reference */
if (pFunc && PyCallable_Check(pFunc)) {
PyObject *pPluginDefinition,
*pRetVal;
pPluginDefinition = PyString_FromString((char *)value);
if (!pPluginDefinition) {
goto bail_out;
}
pRetVal = PyObject_CallFunctionObjArgs(pFunc, p_ctx->bpContext, pPluginDefinition, NULL);
Py_DECREF(pPluginDefinition);
if (!pRetVal) {
goto bail_out;
} else {
retval = conv_python_retval(pRetVal);
Py_DECREF(pRetVal);
}
} else {
Dmsg(ctx, dbglvl, "Failed to find function named load_bareos_plugins()\n");
goto bail_out;
}
}
/*
* Keep track we successfully loaded.
*/
p_ctx->python_loaded = true;
return retval;
bail_out:
if (PyErr_Occurred()) {
PyErrorHandler(ctx, M_FATAL);
}
return retval;
}
void ThreadProc( void *data )
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyThreadState *mainThreadState, *myThreadState, *tempState;
PyInterpreterState *mainInterpreterState;
CMD_LINE_STRUCT* arg = (CMD_LINE_STRUCT*)data;
// Initialize python inerpreter
Py_Initialize();
// Initialize thread support
PyEval_InitThreads();
// Save a pointer to the main PyThreadState object
mainThreadState = PyThreadState_Get();
// Get a reference to the PyInterpreterState
mainInterpreterState = mainThreadState->interp;
// Create a thread state object for this thread
myThreadState = PyThreadState_New(mainInterpreterState);
// Release global lock
PyEval_ReleaseLock();
// Acquire global lock
PyEval_AcquireLock();
// Swap in my thread state
tempState = PyThreadState_Swap(myThreadState);
// Now execute some python code (call python functions)
pName = PyString_FromString(arg->argv[1]);
pModule = PyImport_Import(pName);
// pDict and pFunc are borrowed references
pDict = PyModule_GetDict(pModule);
pFunc = PyDict_GetItemString(pDict, arg->argv[2]);
if (PyCallable_Check(pFunc))
{
PyObject_CallObject(pFunc, NULL);
}
else {
PyErr_Print();
}
// Clean up
Py_DECREF(pModule);
Py_DECREF(pName);
// Swap out the current thread
PyThreadState_Swap(tempState);
// Release global lock
PyEval_ReleaseLock();
// Clean up thread state
PyThreadState_Clear(myThreadState);
PyThreadState_Delete(myThreadState);
Py_Finalize();
printf("My thread is finishing...\n");
// Exiting the thread
#ifdef WIN32
// Windows code
_endthread();
#else
// POSIX code
pthread_exit(NULL);
#endif
}
bool EntityApp<E>::installPyModules()
{
Entities<E>::installScript(NULL);
//Entity::installScript(g_script.getModule());
pEntities_ = new Entities<E>();
registerPyObjectToScript("entities", pEntities_);
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
// 添加pywatcher支持
if(!initializePyWatcher(&this->getScript()))
return false;
// 添加globalData, globalBases支持
pGlobalData_ = new GlobalDataClient(DBMGR_TYPE, GlobalDataServer::GLOBAL_DATA);
registerPyObjectToScript("globalData", pGlobalData_);
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 文件操作
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0);
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
onInstallPyModules();
return true;
}
int guava_request_on_message_complete(http_parser *parser) {
guava_conn_t *conn = (guava_conn_t *)parser->data;
Request *request = (Request *)conn->request;
guava_server_t *server = conn->server;
Router *router = NULL;
Handler *handler = NULL;
guava_response_t *resp = guava_response_new();
guava_response_set_conn(resp, conn);
Py_ssize_t nrouters = PyList_Size(server->routers);
do {
router = (Router *)guava_router_get_best_matched_router((PyObject *)server->routers, (PyObject *)request);
if (router) {
if (router->router->type == GUAVA_ROUTER_STATIC) {
guava_handler_static(router->router, conn, ((Request *)conn->request)->req, resp, on_write, on_sendfile);
break;
} else {
handler = (Handler *)PyObject_CallMethod((PyObject *)router, "route", "(O)", request);
handler->handler->router = router->router;
}
}
for (Py_ssize_t i = 0; i < nrouters; ++i) {
router = (Router *)PyList_GetItem(server->routers, i);
if (router->router->type != GUAVA_ROUTER_CUSTOM) {
/*
* Cause we already try to get the best matched router
* But we still need to pass the custome router in case use defined some speciall routes
*/
continue;
}
Handler *h = (Handler *)PyObject_CallMethod((PyObject *)router, "route", "(O)", request);
if ((PyObject *)h != Py_None) {
handler = h;
handler->handler->router = router->router;
break;
}
}
if (!guava_handler_is_valid(handler->handler) || handler->handler->flags & GUAVA_HANDLER_404) {
guava_response_404(resp, NULL);
guava_response_send(resp, on_write);
break;
}
if (handler->handler->flags & GUAVA_HANDLER_REDIRECT) {
PyObject *location = PyTuple_GetItem(handler->handler->args, 0);
guava_response_302(resp, PyString_AsString(location));
guava_response_send(resp, on_write);
break;
}
if (handler->handler->router->type == GUAVA_ROUTER_STATIC) {
guava_handler_static(handler->handler->router, conn, ((Request *)conn->request)->req, resp, on_write, on_sendfile);
break;
}
PyObject *module_name = NULL;
if (guava_string_equal_raw(handler->handler->package, ".")) {
module_name = PyString_FromString(handler->handler->module);
} else {
module_name = PyString_FromFormat("%s.%s", handler->handler->package, handler->handler->module);
}
PyObject *module = PyImport_Import(module_name);
Py_DECREF(module_name);
if (!module) {
fprintf(stderr, "no module named: %s\n", PyString_AsString(module_name));
if (PyErr_Occurred()) {
PyErr_Print();
}
guava_response_500(resp, NULL);
guava_response_send(resp, on_write);
break;
}
PyObject *cls_name = PyString_FromString(handler->handler->cls);
PyObject *cls = PyObject_GetAttr(module, cls_name);
Py_DECREF(module);
Py_DECREF(cls_name);
if (!cls) {
fprintf(stderr, "no cls named: %s\n", PyString_AsString(cls_name));
if (PyErr_Occurred()) {
PyErr_Print();
}
guava_response_500(resp, NULL);
guava_response_send(resp, on_write);
break;
}
Controller *c = (Controller *)PyObject_CallObject(cls, NULL);
if (!PyObject_TypeCheck(c, &ControllerType)) {
fprintf(stderr, "You controller class must inherit from guava.controller.Controller\n");
guava_response_500(resp, NULL);
guava_response_send(resp, on_write);
break;
}
Py_DECREF(cls);
c->resp = resp;
c->req = ((Request *)conn->request)->req;
c->router = handler->handler->router;
PyObject *r = NULL;
if (handler->handler->args) {
r = PyObject_CallMethod((PyObject *)c, handler->handler->action, "O", handler->handler->args);
} else {
r = PyObject_CallMethod((PyObject *)c, handler->handler->action, NULL);
}
if (!r) {
Py_DECREF(c);
if (PyErr_Occurred()) {
PyErr_Print();
}
fprintf(stderr, "failed to execute action: %s\n", handler->handler->action);
guava_response_500(resp, NULL);
guava_response_send(resp, on_write);
break;
}
if (handler->handler->router->session_store && c->SESSION) {
guava_request_t *r = ((Request *)conn->request)->req;
PyObject *sid_cookie = PyDict_GetItemString(r->COOKIES, handler->handler->router->session_store->name);
guava_session_id_t sid = NULL;
if (sid) {
sid = guava_string_new(((Cookie *)sid_cookie)->data.value);
} else {
sid = guava_session_new_id();
}
guava_session_set(handler->handler->router->session_store, sid, c->SESSION);
}
Py_DECREF(c);
guava_response_send(resp, on_write);
} while(0);
Py_XDECREF(handler);
Py_XDECREF(conn->request);
return 0;
}
int main(int argc, char *argv[])
{
Py_Initialize();
if(!Py_IsInitialized())
{
return -1;
}
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");
PyObject* pName;
PyObject* pModule;
PyObject* pDict;
PyObject* pFunc;
pName = PyString_FromString("call");
pModule = PyImport_Import(pName);
if(!pModule)
{
printf("can't find call.py");
getchar();
return -1;
}
pDict = PyModule_GetDict(pModule);
if(!pDict)
{
return -1;
}
{
pFunc = PyDict_GetItemString(pDict,"test");
if(!pFunc || !PyCallable_Check(pFunc))
{
printf("can't find function [test]");
getchar();
return -1;
}
PyObject_CallObject(pFunc,0);
}
{
pFunc = PyDict_GetItemString(pDict,"add");
if(!pFunc || !PyCallable_Check(pFunc))
{
printf("can't find function [test]");
getchar();
return -1;
}
PyObject* args = PyTuple_New(2);
PyTuple_SetItem(args,0,Py_BuildValue("l",3));
PyTuple_SetItem(args,1,Py_BuildValue("l",4));
PyObject *pAdded = PyObject_CallObject(pFunc,args);
int ret = PyInt_AsLong(pAdded);
printf("add value:%d\n",ret);
Py_DECREF(args);
}
Py_DECREF(pName);
Py_DECREF(pDict);
Py_DECREF(pModule);
Py_Finalize();
system("PAUSE");
return 0;
}
static int proxenet_python_initialize_function(plugin_t* plugin, req_t type)
{
char* module_name;
PyObject *pModStr, *pMod, *pFunc;
const char* function_name;
bool is_request = (type==REQUEST) ? true : false;
/* checks */
if (!plugin->name) {
xlog_python(LOG_ERROR, "%s\n", "null plugin name");
return -1;
}
if (plugin->pre_function && type == REQUEST) {
if(cfg->verbose)
xlog_python(LOG_WARNING, "Pre-hook function already defined for '%s'\n", plugin->name);
return 0;
}
if (plugin->post_function && type == RESPONSE) {
if(cfg->verbose)
xlog_python(LOG_WARNING, "Post-hook function already defined for '%s'\n", plugin->name);
return 0;
}
function_name = is_request ? CFG_REQUEST_PLUGIN_FUNCTION : CFG_RESPONSE_PLUGIN_FUNCTION;
module_name = plugin->name;
pModStr = PYTHON_FROMSTRING(module_name);
if (!pModStr) {
PyErr_Print();
return -1;
}
pMod = PyImport_Import(pModStr);
if(!pMod) {
xlog_python(LOG_ERROR, "Failed to import '%s'\n", module_name);
PyErr_Print();
Py_DECREF(pModStr);
return -1;
}
Py_DECREF(pModStr);
#ifdef DEBUG
xlog_python(LOG_DEBUG, "Importing '%s.%s'\n", module_name, function_name);
#endif
/* find reference to function in module */
pFunc = PyObject_GetAttrString(pMod, function_name);
if (!pFunc) {
PyErr_Print();
return -1;
}
if (!PyCallable_Check(pFunc)) {
xlog_python(LOG_ERROR, "Object in %s is not callable\n", module_name);
return -1;
}
if (is_request)
plugin->pre_function = pFunc;
else
plugin->post_function = pFunc;
return 0;
}
int spyceRequest(webs_t wp, char_t *lpath)
{
// initialize python first
if(!spyInitialized)
{
g_pythonParser.Initialize();
PyEval_AcquireLock();
PyInterpreterState * mainInterpreterState = g_pythonParser.getMainThreadState()->interp;
spyThreadState = PyThreadState_New(mainInterpreterState);
PyThreadState_Swap(spyThreadState);
PyObject* pName = PyString_FromString("spyceXbmc");
PyObject* pModule = PyImport_Import(pName);
Py_XDECREF(pName);
if(!pModule) websError(wp, 500, (char*)"%s", (char*)"Corrupted Spyce installation");
else
{
PyObject* pDict = PyModule_GetDict(pModule);
Py_XDECREF(pModule);
spyFunc = PyDict_GetItemString(pDict, "ParseFile");
if(!spyFunc) websError(wp, 500, (char*)"%s", (char*)"Corrupted Spyce installation");
else spyInitialized = true;
}
PyThreadState_Swap(NULL);
PyEval_ReleaseLock();
if(!spyInitialized)
{
PyThreadState_Clear(spyThreadState);
PyThreadState_Delete(spyThreadState);
g_pythonParser.Finalize();
return -1;
}
}
PyEval_AcquireLock();
PyThreadState_Swap(spyThreadState);
std::string strRequestMethod;
std::string strQuery = wp->query;
std::string strCookie;
int iContentLength = 0;
if (strlen(wp->query) > 0)
{
if(wp->flags & WEBS_POST_REQUEST) strRequestMethod = "POST";
else if (wp->flags & WEBS_HEAD_REQUEST) strRequestMethod = "HEAD";
else strRequestMethod = "GET";
}
if (wp->flags & WEBS_COOKIE) strCookie = wp->cookie;
iContentLength = strQuery.length();
// create enviroment and parse file
PyObject* pEnv = PyDict_New();
PyObject* pREQUEST_METHOD = PyString_FromString(strRequestMethod.c_str());
PyObject* pCONTENT_LENGTH = PyInt_FromLong(iContentLength);
PyObject* pQUERY_STRING = PyString_FromString(strQuery.c_str());
PyObject* pHTTP_COOKIE = PyString_FromString(strCookie.c_str());
PyObject* pCONTENT_TYPE = PyString_FromString(wp->type);
PyObject* pHTTP_HOST = PyString_FromString(wp->host);
PyObject* pHTTP_USER_AGENT = PyString_FromString(wp->userAgent ? wp->userAgent : "");
PyObject* pHTTP_CONNECTION = PyString_FromString((wp->flags & WEBS_KEEP_ALIVE)? "Keep-Alive" : "");
PyDict_SetItemString(pEnv, "REQUEST_METHOD", pREQUEST_METHOD);
PyDict_SetItemString(pEnv, "CONTENT_LENGTH", pCONTENT_LENGTH);
PyDict_SetItemString(pEnv, "QUERY_STRING", pQUERY_STRING);
PyDict_SetItemString(pEnv, "HTTP_COOKIE", pHTTP_COOKIE);
//PyDict_SetItemString(pEnv, "CONTENT_TYPE", pCONTENT_TYPE);
PyDict_SetItemString(pEnv, "HTTP_HOST", pHTTP_HOST);
PyDict_SetItemString(pEnv, "HTTP_USER_AGENT", pHTTP_USER_AGENT);
PyDict_SetItemString(pEnv, "HTTP_CONNECTION", pHTTP_CONNECTION);
PyObject* pResult = PyObject_CallFunction(spyFunc, (char*)"sO", lpath, pEnv);
Py_XDECREF(pREQUEST_METHOD);
Py_XDECREF(pCONTENT_LENGTH);
Py_XDECREF(pQUERY_STRING);
Py_XDECREF(pHTTP_COOKIE);
Py_XDECREF(pCONTENT_TYPE);
Py_XDECREF(pHTTP_HOST);
Py_XDECREF(pHTTP_USER_AGENT);
Py_XDECREF(pHTTP_CONNECTION);
Py_XDECREF(pEnv);
if(!pResult) websError(wp, 500, (char*)"%s", (char*)"Corrupted Spyce installation");
else
{
char* cResult = PyString_AsString(pResult);
websWriteBlock(wp, cResult, strlen(cResult));
Py_XDECREF(pResult);
}
PyThreadState_Swap(NULL);
PyEval_ReleaseLock();
/*
* Common exit and cleanup
*/
if (websValid(wp)) {
websPageClose(wp);
}
return 0;
}
//-------------------------------------------------------------------------------------
bool Bots::installPyModules()
{
ClientObject::installScript(NULL);
PyBots::installScript(NULL);
pPyBots_ = new PyBots();
registerPyObjectToScript("bots", pPyBots_);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addBots, __py_addBots, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0)
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
registerScript(client::Entity::getScriptType());
// 安装入口模块
PyObject *entryScriptFileName = PyUnicode_FromString(g_kbeSrvConfig.getBots().entryScriptFile);
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
if (PyErr_Occurred())
{
INFO_MSG(fmt::format("EntityApp::installPyModules: importing scripts/bots/{}.py...\n",
g_kbeSrvConfig.getBots().entryScriptFile));
PyErr_PrintEx(0);
}
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
onInstallPyModules();
return true;
}
int c_function(int *n, float **mat)
{
PyObject *pModule = NULL;
PyObject *pFunc = NULL;
PyObject *pArg = NULL;
PyObject *pRet = NULL;
PyObject *pName = NULL;
size_t size = *n;
npy_intp *dim;
int i, j;
dim = (npy_intp *) malloc(sizeof(npy_intp)*(size));
for (i=0; i < size; i++) dim[i] = size;
Py_Initialize();
if (!Py_IsInitialized())
{
fprintf(stderr, "nao foi possivel inicializar o python!\n");
return -1;
}
init_numpy();
PyObject* pMat = PyArray_NewFromDescr(
&PyArray_Type, PyArray_DescrFromType(NPY_FLOAT),
2, dim, NULL, (void *) *mat, NPY_ARRAY_INOUT_FARRAY, NULL);
Py_INCREF(pMat);
pName = PyString_FromString("function");
pModule = PyImport_Import(pName);
pFunc = PyObject_GetAttrString(pModule, "py_function");
if(!PyCallable_Check(pFunc))
{
printf("func not callable!\n");
return -1;
}
pArg = PyTuple_New (2);
PyTuple_SetItem(pArg, 0, (PyObject *) PyInt_FromLong(size));
PyTuple_SetItem(pArg, 1, pMat);
pRet = PyObject_CallObject(pFunc, pArg);
printf("py ret: %s\n", PyString_AsString(pRet));
Py_DECREF (pMat);
Py_DECREF (pName);
Py_DECREF (pModule);
Py_DECREF (pFunc);
Py_DECREF (pArg);
Py_DECREF (pRet);
Py_Finalize();
return 0;
}
int
main()
{
// initial the interpreter
char xv[100] = "abcdefg";
PyObject * tstr = PyString_FromString(xv);
Py_Initialize();
if (!Py_IsInitialized()) {
return -1;
}
// import the sys module
PyRun_SimpleString("import sys");
// add the current path to sys.path
PyRun_SimpleString("sys.path.append('./')");
PyObject * pModule = NULL;
PyObject * pFunc = NULL;
PyObject * pName = NULL;
PyObject * pModule1 = NULL;
PyObject * pFunc1 = NULL;
PyObject * pDict = NULL;
PyObject * pArgs = NULL;
PyObject * pFunc2 = NULL;
pName = PyString_FromString("pytest");
pModule1 = PyImport_Import(pName);
if (!pModule1) {
printf("can't find pytest.py");
getchar();
return -1;
}
pDict = PyModule_GetDict(pModule1);
if (!pDict) {
return -1;
}
pFunc1 = PyDict_GetItemString(pDict, "add");
if (!pFunc1 || !PyCallable_Check(pFunc1)) {
printf("can't find function [add]");
getchar();
return -1;
}
pFunc2 = PyDict_GetItemString(pDict, "echo");
if (!pFunc2 || !PyCallable_Check(pFunc2)) {
printf("can't find function [echo]");
getchar();
return -1;
}
pArgs = PyTuple_New(1);
printf("array size = %d \n", PyTuple_Size(pArgs));
PyTuple_SetItem(pArgs, 0, tstr);
PyObject_CallObject(pFunc2, pArgs);
// create a Tuple(2)
pArgs = PyTuple_New(2);
// create long int and make Tumple points it
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l", 3));
PyTuple_SetItem(pArgs, 1, Py_BuildValue("l", 4));
// call a function with parameters
PyObject_CallObject(pFunc1, pArgs);
// reuse the pFunc1 parameter
pFunc1 = PyDict_GetItemString(pDict, "foo");
if(!pFunc1 || !PyCallable_Check(pFunc1)) {
printf("can't find function [foo]");
getchar();
return -1;
}
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l", 2));
PyObject_CallObject(pFunc1, pArgs);
// a another way to import a module
pModule = PyImport_ImportModule("helloworld");
// find a function in a module
pFunc = PyObject_GetAttrString(pModule, "hello");
// call the function
PyEval_CallObject(pFunc, NULL);
// free the memory
Py_DECREF(pName);
Py_DECREF(pArgs);
Py_DECREF(pModule1);
Py_DECREF(pModule);
// close python, release the resource
Py_Finalize();
return 0;
}
int *CA_LoadCells(char *pattern, int width) {
PyObject *pModuleName; // the name of the module
PyObject *pModule; // the module object
PyObject *pFunc; // the callable object
PyObject *pWidth; // the width parameter of the CA
PyObject *pArgs; // the argument list to the callable
PyObject *pResult; // the result of the python invocation
char *module_name = "capattern";
int i;
// initialize the python interpreter
Py_Initialize();
// add current directory to sys.path, so that import can succeed
// alternative approach is to export: PYTHONPATH=. when starting the executable
// NOTE: this is somehow wrong as it replaces sys.path
//PySys_SetPath(".");
// import the module
pModuleName = PyString_FromString(module_name);
pModule = PyImport_Import(pModuleName);
if (pModule == NULL) {
fprintf(stderr, "error: could not import module: %s\n", module_name);
if (PyErr_Occurred()) {
PyErr_Print();
}
return NULL;
}
// get a reference to the callable with the specified name
pFunc = PyObject_GetAttrString(pModule, pattern);
if (pFunc == NULL) {
fprintf(stderr, "error: could not find callable: %s\n", pattern);
return NULL;
}
if (!PyCallable_Check(pFunc)) {
fprintf(stderr, "error: %s is not callable\n", pattern);
return NULL;
}
// prepare the arguments for the callable
pWidth = PyInt_FromLong(width);
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, pWidth);
// invoke the callable with the arguments
pResult = PyObject_CallObject(pFunc, pArgs);
// check for errors
if (PyErr_Occurred()) {
PyErr_Print();
return NULL;
}
// check whether the result is a sequence
if (!PySequence_Check(pResult)) {
fprintf(stderr, "error: result is not a sequence\n");
return NULL;
}
// check length of returned result
if (PySequence_Size(pResult) != width) {
fprintf(stderr, "error: returned sequence has incorrect length\n");
}
// allocate cells
int *cells = (int *) malloc(width * sizeof(int));
// iterate over elements in sequence
for (i=0; i<width; i++) {
// check that the element is an integer
PyObject *pElement;
pElement = PySequence_GetItem(pResult, i);
if (!PyInt_Check(pElement)) {
fprintf(stderr, "error: element with index %d is not an integer\n", i);
return NULL;
}
// check that the element is equal to one or zero
int value = PyInt_AsLong(pElement);
if (!((value == 0) || (value == 1))) {
fprintf(stderr, "error: element with index %d is not 0 or 1\n", i);
return NULL;
}
// get the cell
*(cells+i) = value;
}
Py_Finalize();
return cells;
}
bool obs_module_load()
{
blog(LOG_INFO, "obs_module_load");
//Need to init python here
//load the swig
Py_Initialize();
PyEval_InitThreads();
/*Must set arguments for guis to work*/
wchar_t* argv[] = { L"", NULL };
int argc = sizeof(argv) / sizeof(wchar_t*) - 1;
//SWIG_init();
PySys_SetArgv(argc, argv);
//need to add to directory
PyRun_SimpleString("import os");
PyRun_SimpleString("import sys");
PyRun_SimpleString("os.environ['PYTHONUNBUFFERED'] = '1'");
PyRun_SimpleString("sys.stdout = open('/dev/shm/stdOut.txt','w',1)");
PyRun_SimpleString("sys.stderr = open('/dev/shm/stdErr.txt','w',1)");
PyRun_SimpleString("print(sys.version)");
/*Load a file*/
PyObject* pName, *pModule, *pFunc,*argList;
pName = PyUnicode_FromString("source");
char script[] = "/scripts";
const char *data_path = obs_get_module_data_path(obs_current_module());
char *scripts_path = bzalloc(strlen(data_path)+strlen(script));
strcpy(scripts_path,data_path);
strcat(scripts_path,script);
//Add the path to env
add_to_python_path(scripts_path);
bfree(scripts_path);
//PyImport_AppendInittab("_libobs", PyInit_libobs);
/*Import libobs*/
//Py_XDECREF(main_module);
//Add our custom stuff to libobs
//import the script
pModule = PyImport_Import(pName);
pyHasError();
//get the function by name
if(pModule != NULL) {
PyObject *ns = PyModule_GetDict(pModule);
Py_INCREF(ns);
PyObject *py_libobs = PyImport_ImportModuleEx("obspython",ns,ns,NULL);
Py_INCREF(py_libobs);
extend_swig_libobs(py_libobs);
PyModule_AddObject(pModule,"obspython",py_libobs);
pFunc = PyObject_GetAttr(pModule, PyUnicode_FromString("register"));
if(pFunc != NULL) {
argList = Py_BuildValue("()");
PyObject_CallObject(pFunc,argList);
pyHasError();
Py_XDECREF(pFunc);
Py_XDECREF(argList);
}
Py_XDECREF(pModule);
}
Py_XDECREF(pName);
//Not implemented yet?
//obs_register_modal_ui(&myui);
//Register this base class here
obs_register_source(&python_source_info);
//Release the thread gill
PyThreadState* pts = PyGILState_GetThisThreadState();
PyEval_ReleaseThread(pts);
return true;
}
bool obs_module_load()
{
blog(LOG_INFO, "obs_module_load");
if(!is_python_on_path()){
blog(LOG_WARNING,
"%s:l%i \"Warning could not detect python environment variables attempting to load shared library anyway\"",
__func__,
__LINE__
);
}
// Manually force python to be loaded
#if __GNUC__
if(!os_dlopen_global(PYTHON_SHARED_LIBRARY_NAME)){
#else
if(!os_dlopen(PYTHON_SHARED_LIBRARY_NAME)){
#endif
blog(LOG_ERROR,
"%s:l%i \"Error Could not load python shared library %s aborting!\"",
__func__,
__LINE__,
PYTHON_SHARED_LIBRARY_NAME
);
return false;
}
Py_Initialize();
PyEval_InitThreads();
/*Must set arguments for guis to work*/
wchar_t* argv[] = { L"", NULL };
int argc = sizeof(argv) / sizeof(wchar_t*) - 1;
PySys_SetArgv(argc, argv);
/* Setup logs to a safe place can be changed by user in OBSPythonManager.py register function*/
PyRun_SimpleString("import os");
PyRun_SimpleString("import sys");
PyRun_SimpleString("os.environ['PYTHONUNBUFFERED'] = '1'");
/* TODO change to non platform specific */
PyRun_SimpleString("sys.stdout = open('./stdOut.txt','w',1)");
PyRun_SimpleString("sys.stderr = open('./stdErr.txt','w',1)");
PyRun_SimpleString("print(sys.version)");
/*Load manager from file*/
PyObject* pName = NULL;
PyObject* pModule = NULL;
PyObject* pFunc = NULL;
PyObject* argList = NULL;
bool ret = false;
char script[] = "/scripts";
char arch[] = PLUGINARCH;
const char *data_path = obs_get_module_data_path(obs_current_module());
char *scripts_path = bzalloc(strlen(data_path)+strlen(script));
strcpy(scripts_path,data_path);
strcat(scripts_path,script);
//Add the scripts path to env
add_to_python_path(scripts_path);
bfree(scripts_path);
scripts_path = bzalloc(strlen(data_path)+strlen(arch));
strcpy(scripts_path,data_path);
strcat(scripts_path,arch);
//Add the plugin obspython arch path to env
add_to_python_path(scripts_path);
/* load the obspython library and extend with manually written functions/objects */
PyObject *py_libobs = PyImport_ImportModule("obspython");
ret = pyHasError();
if (ret){
blog(LOG_INFO,
"%s:l%i \"Error importing '%s/obspython.py' unloading obs-python\"",
__func__,
__LINE__,
scripts_path
);
goto out;
}
extend_swig_libobs(py_libobs);
//Import the manager script
pName = PyUnicode_FromString("OBSPythonManager");
pModule = PyImport_Import(pName);
ret = pyHasError();
if (ret){
blog(LOG_INFO,
"%s:l%i \"Error loading '%s/OBSPythonManager.py' unloading obs-python\"",
__func__,
__LINE__,
scripts_path
);
goto out;
}
//get the function by name
if(pModule != NULL) {
PyModule_AddObject(pModule,"obspython",py_libobs);
pFunc = PyObject_GetAttr(pModule, PyUnicode_FromString("obs_module_load"));
if(pFunc != NULL) {
argList = Py_BuildValue("()");
PyObject_CallObject(pFunc,argList);
ret = pyHasError();
if (ret){
blog(LOG_INFO,
"%s:l%i \"Error running 'register' function in '%s/OBSPythonManager.py' unloading obs-python\"",
__func__,
__LINE__,
scripts_path
);
goto out;
}
}else{
ret = pyHasError();
blog(LOG_INFO,
"%s:l%i \"Could not find register function in '%s/OBSPythonManager.py' unloading obs-python\"",
__func__,
__LINE__,
scripts_path
);
}
goto out;
}
out:
bfree(scripts_path);
Py_XDECREF(pFunc);
Py_XDECREF(argList);
Py_XDECREF(pModule);
Py_XDECREF(pName);
//Release the thread GIL
PyThreadState* pts = PyGILState_GetThisThreadState();
PyEval_ReleaseThread(pts);
if(!ret){
return true;
}else{
obs_module_unload();
return false;
}
}
void obs_module_unload()
{
//Shutdown python and call shutdown functions
blog(LOG_INFO, "obs_module_unload");
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
UNUSED_PARAMETER(gstate);
if (Py_IsInitialized()) {
Py_Finalize();
}
}
char *pycall(PgSocket *client, char *username, char *query_str, char *py_file,
char* py_function) {
PyObject *pName = NULL, *pModule = NULL, *pFunc = NULL;
PyObject *pArgs = NULL, *pValue = NULL;
PyObject *ptype, *perror, *ptraceback;
char *py_pathtmp, *py_filetmp, *py_path, *py_module, *ext;
char *res = NULL;
/* setup python search path */
py_pathtmp = malloc(strlen(py_file) + 1);
strcpy(py_pathtmp, py_file);
py_path = malloc(strlen(py_file) + 20) ;
sprintf(py_path,"PYTHONPATH=%s",dirname(py_pathtmp)) ;
putenv(py_path) ;
/* setup python module name, function name */
py_filetmp = malloc(strlen(py_file) + 1);
strcpy(py_filetmp, py_file);
py_module = (char *) basename(py_filetmp);
ext = strrchr(py_module, '.');
if (ext)
ext[0] = '\0';
/* Initialize the Python interpreter
* NOTE: This call is a no-op on subsequent calls, as we do not
* call PyFinalize(). This
* a) avoids the overhead of repeatedly reloading the interpreter
* b) allows the use of global variables for persisting data in the
* routing / rewriting functions between calls.
*/
Py_Initialize();
/* Load python module */
pName = PyString_FromString(py_module);
pModule = PyImport_Import(pName);
if (pModule == NULL) {
slog_error(client, "Python module <%s> did not load", py_module);
goto finish;
}
/* Prepare to call python function */
pFunc = PyObject_GetAttrString(pModule, py_function);
if (!pFunc) {
slog_error(client, "Python Function <%s> not found in module <%s>",
py_function, py_module);
goto finish;
}
if (!PyCallable_Check(pFunc)) {
slog_error(client,
"Python Function <%s> in module <%s> is not callable!",
py_function, py_module);
goto finish;
}
/* Call function with two arguments - username and query_str */
pArgs = PyTuple_New(2);
pValue = PyString_FromString(username);
PyTuple_SetItem(pArgs, 0, pValue);
pValue = PyString_FromString(query_str);
PyTuple_SetItem(pArgs, 1, pValue);
pValue = PyObject_CallObject(pFunc, pArgs);
if (pValue == NULL) {
slog_error(client, "Python Function <%s> failed to return a value",
py_function);
goto finish;
}
if (PyString_Check(pValue)) {
res = malloc(strlen(PyString_AsString(pValue)) + 1);
strcpy(res, PyString_AsString(pValue));
} else {
res = NULL;
}
finish:
if (PyErr_Occurred()) {
PyErr_Fetch(&ptype, &perror, &ptraceback);
slog_error(client, "Python error: %s", PyString_AsString(perror));
}
free(py_pathtmp);
free(py_filetmp);
free(py_path);
Py_XDECREF(pName);
Py_XDECREF(pModule);
Py_XDECREF(pFunc);
Py_XDECREF(pArgs);
Py_XDECREF(pValue);
return res;
}
static int python_connect(vfs_handle_struct *handle, const char *service, const char *user)
{
PyObject *pRet, *pArgs, *pValue, *pSysPath;
const char *pysource_const, *pyarg;
char pysource[PY_MAXPATH];
struct pyfuncs *pf;
int i;
pf = SMB_MALLOC_P(struct pyfuncs);
if (!pf) {
errno = ENOMEM;
return -1;
}
handle->data = (void *)pf;
handle->free_data = free_python_data;
memset(pf, 0, sizeof(*pf));
pysource_const = lp_parm_const_string(SNUM(handle->conn), "vfs_python", "module_name", NULL);
if (!pysource_const || pysource_const[0] == '\0') {
DEBUG(1, ("vfs_python: module_name not set!\n"));
errno = E_INTERNAL;
return -1;
}
/* strlen doesn't count the trailing NULL, so even if they're the same
length it's no good. */
if (strlen(pysource_const) >= sizeof(pysource)) {
DEBUG(1, ("vfs_python: module_name too long!\n"));
errno = ENOMEM;
return -1;
}
/* Silly, but some implementations of dirname and basename modify their
input parameters. */
strncpy((char *) &pysource, pysource_const, sizeof(pysource));
pyarg = dirname((char *) &pysource);
/* If we have a path, add it to Python's search path. */
if (pyarg) {
/* Note PySys_GetObject returns a borrowed reference */
pSysPath = PySys_GetObject("path");
if (!pSysPath) {
errno = E_INTERNAL;
return -1;
}
pArgs = PyString_FromString(pyarg);
if (!pArgs) {
errno = E_INTERNAL;
return -1;
}
i = PyList_Append(pSysPath, pArgs);
Py_DECREF(pArgs);
if (i < 0) {
errno = E_INTERNAL;
return -1;
}
}
/* Now actually include the module (by its basename). */
strncpy((char *) &pysource, pysource_const, sizeof(pysource));
pyarg = basename((char *) &pysource);
if (!pyarg || pyarg[0] == '\0') {
DEBUG(1, ("vfs_python: Invalid module_name!\n"));
errno = E_INTERNAL;
return -1;
}
pArgs = PyString_FromString(pyarg);
pf->pModule = PyImport_Import(pArgs);
Py_DECREF(pArgs);
if (!pf->pModule) {
DEBUG(1, ("vfs_python: Failed to load module '%s'. Make sure not to include a trailing '.py' or '.pyc' in your module path.\n", pysource_const));
PyErr_Print();
errno = E_INTERNAL;
return -1;
}
#define VFS_PY_REQUIRED_MODULE_FUNC(_member, _name) \
pf->pFunc##_member = PyObject_GetAttrString(pf->pModule, _name); \
if (!pf->pFunc##_member || !PyCallable_Check(pf->pFunc##_member)) { \
if (pf->pFunc##_member) Py_DECREF(pf->pFunc##_member); \
DEBUG(1, ("vfs_python: %s function not found or not callable\n", _name)); \
errno = E_INTERNAL; \
return -1; \
}
#define VFS_PY_OPTIONAL_MODULE_FUNC(_member, _name) \
pf->pFunc##_member = PyObject_GetAttrString(pf->pModule, _name); \
if (!pf->pFunc##_member) { \
pf->pFunc##_member = NULL; \
PyErr_Clear(); \
} \
else if (!PyCallable_Check(pf->pFunc##_member)) { \
Py_DECREF(pf->pFunc##_member); \
pf->pFunc##_member = NULL; \
}
pf->pErrno = PyObject_GetAttrString(pf->pModule, "vfs_errno");
if (pf->pErrno && !PyInt_Check(pf->pErrno)) {
Py_DECREF(pf->pErrno);
DEBUG(1, ("vfs_python: vfs_errno global variable not an int\n"));
errno = E_INTERNAL;
return -1;
}
VFS_PY_REQUIRED_MODULE_FUNC(Stat, "stat");
VFS_PY_REQUIRED_MODULE_FUNC(GetDir, "getdir");
VFS_PY_REQUIRED_MODULE_FUNC(OpenFile, "open");
VFS_PY_REQUIRED_MODULE_FUNC(Close, "close");
VFS_PY_REQUIRED_MODULE_FUNC(Read, "read");
VFS_PY_REQUIRED_MODULE_FUNC(LSeek, "lseek");
VFS_PY_OPTIONAL_MODULE_FUNC(Unlink, "unlink");
VFS_PY_OPTIONAL_MODULE_FUNC(Write, "write");
VFS_PY_OPTIONAL_MODULE_FUNC(MkDir, "mkdir");
VFS_PY_OPTIONAL_MODULE_FUNC(Unlink, "unlink");
VFS_PY_OPTIONAL_MODULE_FUNC(Rename, "rename");
VFS_PY_OPTIONAL_MODULE_FUNC(FStat, "fstat");
VFS_PY_OPTIONAL_MODULE_FUNC(DiskFree, "diskfree");
VFS_PY_OPTIONAL_MODULE_FUNC(Connect, "connect");
VFS_PY_OPTIONAL_MODULE_FUNC(Disconnect, "disconnect");
VFS_PY_OPTIONAL_MODULE_FUNC(PRead, "pread");
VFS_PY_OPTIONAL_MODULE_FUNC(PWrite, "pwrite");
VFS_PY_OPTIONAL_MODULE_FUNC(Chmod, "chmod");
VFS_PY_OPTIONAL_MODULE_FUNC(FChmod, "fchmod");
VFS_PY_OPTIONAL_MODULE_FUNC(Chown, "chown");
VFS_PY_OPTIONAL_MODULE_FUNC(FChown, "fchown");
VFS_PY_OPTIONAL_MODULE_FUNC(FTruncate, "ftruncate");
VFS_PY_OPTIONAL_MODULE_FUNC(FAllocate, "fallocate");
VFS_PY_OPTIONAL_MODULE_FUNC(Symlink, "symlink");
VFS_PY_OPTIONAL_MODULE_FUNC(Link, "link");
VFS_PY_OPTIONAL_MODULE_FUNC(ReadLink, "readlink");
VFS_PY_OPTIONAL_MODULE_FUNC(IsOffline, "isoffline");
VFS_PY_OPTIONAL_MODULE_FUNC(GetPath, "getpath");
// Init done, do connect
if (pf->pFuncConnect) {
PY_TUPLE_NEW(3);
PY_ADD_TO_TUPLE(service, PyString_FromString, 0);
PY_ADD_TO_TUPLE(user, PyString_FromString, 1);
pyarg = lp_parm_const_string(SNUM(handle->conn), "vfs_python", "connect_arg", NULL);
if (pyarg) {
PY_ADD_TO_TUPLE(pyarg, PyString_FromString, 2);
} else {
PyTuple_SetItem(pArgs, 2, Py_None);
}
PY_CALL_WITH_ARGS(Connect);
i = PyInt_AS_LONG(pRet);
Py_DECREF(pRet);
return i;
}
return 0;
}
// 调用simplehttpserver.py脚本
DWORD WINAPI ThreadFunc(PVOID pVoid)
{
Py_Initialize();
if (!Py_IsInitialized())
{
std::cout << "Py_Initialize() failed" << std::endl;
CLogMgr::GetGlobalInstance()->setLog("Py_IsInitialized() failed");
system("pause");
return 0;
}
if (!PyImport_AddModule("Sample"))
{
std::cout << "Host API module could not be created." << std::endl;
}
PyObject *module = Py_InitModule("Sample", Methods);
if (!module)
{
std::cout << "Host Api functions could not be initialized." << std::endl;
return 0;
}
int v1 = PyRun_SimpleString("import sys");
//int v2 = PyRun_SimpleString("sys.path.append('./')");
PyObject *pName = NULL;
PyObject *pModule = NULL;
PyObject *pDict = NULL;
PyObject *pFunc1 = NULL;
PyObject *pFunc2 = NULL;
PyObject *pArgs1 = NULL;
PyObject *pArgs2 = NULL;
PyObject *pReturn1 = NULL;
PyObject *pReturn2 = NULL;
//载入脚本
pName = PyString_FromString("simplehttpserver");
pModule = PyImport_Import(pName);
if (!pModule)
{
std::cout << "can not find simplehttpserver.py" << std::endl;
CLogMgr::GetGlobalInstance()->setLog("can not find simplehttpserver.py");
system("pause");
return 0;
}
pDict = PyModule_GetDict(pModule);
if (!pDict)
{
std::cout << "PyModule_GetDict failed" << std::endl;
CLogMgr::GetGlobalInstance()->setLog("PyModule_GetDict failed");
system("pause");
return 0;
}
if (pReturn1 != NULL)
{
Py_DECREF(pReturn1);
}
if (pName != NULL)
{
Py_DECREF(pName);
}
if (pArgs1 != NULL)
{
Py_DECREF(pArgs1);
}
if (pArgs2 != NULL)
{
Py_DECREF(pArgs2);
}
if (pModule != NULL)
{
Py_DECREF(pModule);
}
if (pFunc1 != NULL)
{
Py_DECREF(pFunc1);
}
if (pFunc2 != NULL)
{
Py_DECREF(pFunc2);
}
if (pReturn2 != NULL)
{
Py_DECREF(pReturn2);
}
//关闭python
Py_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;
int i;
if (argc < 3) {
fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
return 1;
}
Py_Initialize();
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.insert(0, '')");
/* Module name */
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */
if (pFunc && PyCallable_Check(pFunc)) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
pValue = PyInt_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyInt_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
Py_Finalize();
return 0;
}
private int linkgw_create(struct occi_category * optr, void * vptr, struct rest_request * rptr)
{
struct occi_kind_node * nptr;
struct linkgw * pptr;
char sendstr[1024];
char strtmp[1024];
char srcdir[1024];
char * response = NULL;
char * token;
FILE * exp_file;
listcc categoryAtr;
PyObject *pName=NULL, *pModule=NULL, *pDict=NULL, *pFunc=NULL,*result=NULL;
PyThreadState* pythr=NULL;
if (!( nptr = vptr ))
return(0);
else if (!( pptr = nptr->contents ))
return(0);
if(!(pptr->name)) strcpy(sendstr," ");
else if(pptr->name[0]=='\0') strcpy(sendstr," ");
else strcpy(sendstr,pptr->name);
if(!(pptr->intercloudGW)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->intercloudGW[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->intercloudGW,',');
if(!(pptr->account)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->account[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->account,',');
if(!(pptr->gwsrc)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->gwsrc[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->gwsrc,',');
if(!(pptr->gwdst)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->gwdst[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->gwdst,',');
if(!(pptr->tunnelproto)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->tunnelproto[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->tunnelproto,',');
if(!(pptr->addressgresrc)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->addressgresrc[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->addressgresrc,',');
if(!(pptr->addressgredst)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->addressgredst[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->addressgredst,',');
if(!(pptr->prefix)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->prefix[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->prefix,',');
if(!(pptr->authenticationkey)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->authenticationkey[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->authenticationkey,',');
if(!(pptr->endpointsrc)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->endpointsrc[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->endpointsrc,',');
if(!(pptr->endpointdst)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->endpointdst[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->endpointdst,',');
if(!(pptr->state)){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else if(pptr->state[0]=='\0'){
strcpy(strtmp," ");
strConcat(sendstr,strtmp,',');
}
else strConcat(sendstr,pptr->state,',');
// python interface
sprintf(srcdir,"%s/pyaccords/pysrc",PYPATH);
pythr = Py_NewInterpreter();
python_path(srcdir);
pName = PyString_FromString("linkgw");
if(pName == NULL) printf("erro: in linkgw no such file name\n");
else pModule = PyImport_Import(pName);
if(pModule == NULL) printf("error: failed to load linkgw module\n");
else pDict = PyModule_GetDict(pModule);
if(pDict == NULL) printf("error: failed to load dict name in linkgw module\n");
else pFunc = PyDict_GetItemString(pDict,"create");
if(pFunc == NULL) printf("error: failed to load create function in linkgw module\n");
else result=PyObject_CallFunction(pFunc,"s",sendstr);
if(result) response=allocate_string(PyString_AsString( result ));
Py_DECREF(pModule);
Py_DECREF(pName);
Py_EndInterpreter(pythr);
resetListe(&categoryAtr);
token= strtok(response,",");
for(; token != NULL ;)
{
addBacke(&categoryAtr,token);
token=strtok(NULL, ",");
}
elemm *pelem = categoryAtr.first;
if(pelem){
pptr->name = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->intercloudGW = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->account = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->gwsrc = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->gwdst = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->tunnelproto = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->addressgresrc = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->addressgredst = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->prefix = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->authenticationkey = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->endpointsrc = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->endpointdst = pelem->value;
pelem = pelem->next;
}
if(pelem){
pptr->state = pelem->value;
}
return 1;
}
void CMAC_net::plot_contourf() {
Py_Initialize();
import_array1();
PyObject* p_name, *p_module, *p_dict, *p_func, *p_value, *format_expression,
*run_expression, *run_script, *traceback_module, *python_module,
*traceback_dictionary, *python_dictionary;
traceback_module = PyImport_ImportModule("traceback");
python_module = PyImport_ImportModule("python_fun");
if (traceback_module && python_module) {
traceback_dictionary = PyModule_GetDict(traceback_module);
python_dictionary = PyModule_GetDict(python_module);
format_expression =
PyDict_GetItemString(traceback_dictionary, "format_expression");
run_expression =
PyDict_GetItemString(python_dictionary, "run_expression");
run_script = PyDict_GetItemString(python_dictionary, "run_script");
if (format_expression && run_expression && run_script) {
if (PyCallable_Check(format_expression) &&
PyCallable_Check(run_expression) &&
PyCallable_Check(run_script)) {
}
}
}
fexcp = PyDict_GetItemString(dict1)
const int res = 4;
float** x = new float* [res];
float** y = new float* [res];
float** z = new float* [res];
x[0] = new float[res];
x[1] = x[0] + res;
x[2] = x[1] + res;
y[0] = new float[res];
y[1] = y[0] + res;
y[2] = y[1] + res;
z[0] = new float[res];
z[1] = z[0] + res;
z[2] = z[1] + res;
int mdim[] = {res, res};
float x_step =
interval_width[0] * (float)_tile_resolution / ((float)res - 1);
float y_step =
interval_width[1] * (float)_tile_resolution / ((float)res - 1);
float input_vals[2];
std::ofstream fout;
fout.open("plot_contourf_tmp.txt");
for (int i = 0; i < res; i++) {
for (int j = 0; j < res; j++) {
x[i][j] = _range_inputs[0][0] + x_step * (float)i;
y[i][j] = _range_inputs[0][0] + y_step * (float)j;
input_vals[0] = x[i][j];
input_vals[1] = y[i][j];
sim(&z[i][j], input_vals);
fout << x[i][j] << "," << y[i][j] << "," << z[i][j];
printf("(%.2f,%.2f,%.2f)", x[i][j], y[i][j], z[i][j]);
if (j < res - 1) {
fout << ",";
std::cout << ",";
}
}
fout << std::endl;
printf("\n");
}
fout.close();
PyObject* x_mat = PyArray_SimpleNewFromData(2, mdim, PyArray_DOUBLE, x[0]);
char full_path[256];
char p_path[256];
getcwd(full_path, 255);
strcpy(p_path, "sys.path.append(\"");
strcat(p_path, full_path);
strcat(p_path, "\")");
PyRun_SimpleString("import sys");
PyRun_SimpleString(p_path);
p_name = PyString_FromString("py_plot");
p_module = PyImport_Import(p_name);
if (p_module == NULL) {
printf("Failed to open py_plot.py");
}
p_dict = PyModule_GetDict(p_module);
p_func = PyDict_GetItemString(p_dict, "plot_contourf");
if (PyCallable_Check(p_func)) {
PyObject_CallObject(p_func, NULL);
} else {
PyErr_Print();
}
Py_DECREF(p_module);
Py_DECREF(p_name);
Py_Finalize();
}
// -------------------------------------------------------------------------
// This software is furnished "as is", without technical
// support, and with no warranty, express or implied, as to its usefulness for
// any purpose.
//
// gcal.c
// This file acts as the wrapper around the sp_func.py python library
//
// Author: Vedvyas Shanbhogue
// ------------------------------------------------------------------------*/
#ifdef IDENT_C
static const char* const <filename>_c_Id = "$Id$";
#endif
#include <Python.h>
// -- global -----------------------------------------------------------------
// get_calendar_events()
//
// Returns:
// 0 - success
// 1 - error
// On success return, the duration is set to the duration of the event
// if no event was found then duration is returned as 0
// -------------------------------------------------------------------------*/
int
get_calendar_events(
time_t *duration)
{
PyObject *pName, *pModule, *pDict, *pFunc, *pValue;
struct tm start_time, end_time;
char *start, *end, *name;
char *argv[] = {
"sp",
"sp_func",
"get_cal_events"
};
// Initialize the Python Interpreter
Py_Initialize();
// Build the name object
pName = PyString_FromString(argv[1]);
// Load the module object
PySys_SetArgv(1, argv);
PyErr_Print();
pModule = PyImport_Import(pName);
PyErr_Print();
// pDict is a borrowed reference
pDict = PyModule_GetDict(pModule);
// pFunc is also a borrowed reference
pFunc = PyDict_GetItemString(pDict, argv[2]);
if ( !PyCallable_Check(pFunc) ) {
PyErr_Print();
Py_DECREF(pModule);
Py_DECREF(pName);
Py_Finalize();
return 1;
}
// Get the calendar events from google calendar
pValue = PyObject_CallObject(pFunc, NULL);
// Extract the start time, end time and event name strings
if ( PyArg_ParseTuple(pValue, "sss", &start, &end, &name) == 0 )
{
PyErr_Print();
Py_DECREF(pModule);
Py_DECREF(pName);
Py_Finalize();
return 1;
}
*duration = 0;
// check if any event returned
if ( strlen(start) && strlen(end) && strlen(name) &&
(strcmp(name, "Sprinkler On") == 0) ) {
// Turn time strings into struct tm
strptime(start, "%Y-%m-%dT%T", &start_time);
strptime(end, "%Y-%m-%dT%T", &end_time);
// Check if it is time to start the sprinker
if ( time(NULL) >= mktime(&start_time) &&
time(NULL) < mktime(&end_time) ) {
// Time to start the sprinker for specified duration
*duration = mktime(&end_time) - time(NULL);
}
}
Py_DECREF(pModule);
Py_DECREF(pName);
Py_Finalize();
return 0;
}
int main(int argc, char** argv)
{
// 初始化Python
//在使用Python系统前，必须使用Py_Initialize对其
//进行初始化。它会载入Python的内建模块并添加系统路
//径到模块搜索路径中。这个函数没有返回值，检查系统
//是否初始化成功需要使用Py_IsInitialized。
Py_Initialize();
// 检查初始化是否成功
if ( !Py_IsInitialized() )
{
return -1;
}
// 添加当前路径
//把输入的字符串作为Python代码直接运行，返回0
//表示成功，-1表示有错。大多时候错误都是因为字符串
//中有语法错误。
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");
PyObject *pName,*pModule,*pDict,*pFunc,*pArgs;
// 载入名为pytest的脚本
pName = PyString_FromString("pytest");
pModule = PyImport_Import(pName);
if ( !pModule )
{
printf("can't find pytest.py");
getchar();
return -1;
}
pDict = PyModule_GetDict(pModule);
if ( !pDict )
{
return -1;
}
// 找出函数名为add的函数
pFunc = PyDict_GetItemString(pDict, "add");
if ( !pFunc || !PyCallable_Check(pFunc) )
{
printf("can't find function [add]");
getchar();
return -1;
}
// 参数进栈
*pArgs;
pArgs = PyTuple_New(2);
// PyObject* Py_BuildValue(char *format, ...)
// 把C++的变量转换成一个Python对象。当需要从
// C++传递变量到Python时，就会使用这个函数。此函数
// 有点类似C的printf，但格式不同。常用的格式有
// s 表示字符串，
// i 表示整型变量，
// f 表示浮点数，
// O 表示一个Python对象。
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",3));
PyTuple_SetItem(pArgs, 1, Py_BuildValue("l",4));
// 调用Python函数
PyObject_CallObject(pFunc, pArgs);
//下面这段是查找函数foo 并执行foo
pFunc = PyDict_GetItemString(pDict, "foo");
if ( !pFunc || !PyCallable_Check(pFunc) )
{
printf("can't find function [foo]");
getchar();
return -1;
}
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",2)); //
PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pName);
Py_DECREF(pArgs);
Py_DECREF(pModule);
// 关闭Python
Py_Finalize();
return 0;
}
void pycon_open(){
//initialise python console
Py_Initialize();
PyRun_SimpleString("print 'python present.'");
Py_InitModule("tpt", EmbMethods);
//change the path to find all the correct modules
PyRun_SimpleString("import sys\nsys.path.append('./tptPython.zip')\nsys.path.append('.')");
//load the console module and whatnot
#ifdef PYEXT
PyRun_SimpleString(tpt_console_py);
printf("using external python console file.\n");
pname=PyString_FromString("tpt_console");//create string object
pmodule = PyImport_Import(pname);//import module
Py_DECREF(pname);//throw away string
#else
tpt_console_obj = PyMarshal_ReadObjectFromString(tpt_console_pyc+8, sizeof(tpt_console_pyc)-8);
pmodule=PyImport_ExecCodeModule("tpt_console", tpt_console_obj);
#endif
if (pmodule!=NULL)
{
pfunc=PyObject_GetAttrString(pmodule,"handle");//get the handler function
if (pfunc && PyCallable_Check(pfunc))//check if it's really a function
{
printf("python console ready to go.\n");
}
else
{
PyErr_Print();
printf("unable to find handle function, mangled console.py?\n");
pyready = 0;
pygood = 0;
}
pstep=PyObject_GetAttrString(pmodule,"step");//get the handler function
if (pstep && PyCallable_Check(pstep))//check if it's really a function
{
printf("step function found.\n");
}
else
{
printf("unable to find step function. ignoring.\n");
}
pkey=PyObject_GetAttrString(pmodule,"keypress");//get the handler function
if (pstep && PyCallable_Check(pkey))//check if it's really a function
{
printf("key function found.\n");
}
else
{
printf("unable to find key function. ignoring.\n");
}
}
else
{
//sys.stderr
PyErr_Print();
printf("unable to find console module, missing file or mangled console.py?\n");
pyready = 0;
pygood = 0;
}
}
int importPythonModule (char *binImg1_data,
int binImg1_data_len,
char *binImg2_data,
char binImg2_data_len)
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;
int i;
Py_Initialize();
pName = PyUnicode_DecodeFSDefault("face");
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL)
{
/* pFunc is a new reference */
pFunc = PyObject_GetAttrString(pModule, "get_images_from_cpp");
if (pFunc && PyCallable_Check(pFunc))
{
pArgs = PyTuple_New(2);
pValue = PyBytes_FromStringAndSize ( binImg2_data, binImg1_data_len);;
if (!pValue)
{
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, 0, pValue);
pValue = PyBytes_FromStringAndSize ( binImg2_data, binImg2_data_len);;
if (!pValue)
{
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, 1, pValue);
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL)
{
printf("Result of call: %f\n", PyLong_AsDouble(pValue));
Py_DECREF(pValue);
}
else
{
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else
{
if (PyErr_Occurred())
{
PyErr_Print();
}
fprintf(stderr, "Cannot find function \"%s\"\n", "get_images_from_cpp");
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else
{
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", "face");
return 1;
}
Py_Finalize();
return 0;
}
static foreign_t python_run_script(term_t cmd, term_t fun) {
char si[256], sf[256];
size_t len = 255, len1 = 255;
PyObject *pName, *pModule, *pFunc;
PyObject *pArgs = NULL, *pValue;
char *s;
s = si;
if (PL_get_nchars(cmd, &len, &s, CVT_ALL | CVT_EXCEPTION) &&
(s = sf) != NULL &&
PL_get_nchars(fun, &len1, &s, CVT_ALL | CVT_EXCEPTION)) {
#if PY_MAJOR_VERSION < 3
pName = PyString_FromString("rbm");
#else
// asssumes UTF-8
pName = PyUnicode_FromString("rbm");
#endif
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
PyErr_Clear();
Py_DECREF(pName);
if (pModule != NULL) {
pFunc = PyObject_GetAttrString(pModule, sf);
/* pFunc is a new reference */
if (pFunc && PyCallable_Check(pFunc)) {
pValue = PyObject_CallObject(pFunc, pArgs);
if (pValue != NULL) {
Py_DECREF(pValue);
} else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr, "Call failed\n");
{
return false;
}
}
} else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", sf);
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
} else {
PyErr_Print();
{
return false;
}
}
{
return true;
}
}
{
return false;
}
}
struct matcher_entry *check_block_params(struct matcher_entry *head)
{
if(head->name == NULL) {
printf("You must specify block name\n");
return NULL;
}
if(head->match == NULL) {
printf("Error: block \"%s\" missing match!\n", head->name);
return NULL;
}
#ifdef HAVE_PYTHON
if((head->response == NULL || head->response_len < 1 || head->response_len > MATCHER_MAX_RESPONSE) && head->pyfunc == NULL) {
#else
if((head->response == NULL || head->response_len < 1 || head->response_len > MATCHER_MAX_RESPONSE)) {
#endif
printf("Error: block \"%s\" has missing or malformed response/pymodule!\n", head->name);
return NULL;
}
if(!head->proto) {
printf("Error: block \"%s\" has missing proto\n", head->name);
return NULL;
}
if(head->dst_port >= 65535) {
printf("Error: block \"%s\" has incorrect dst port\n", head->name);
return NULL;
}
if(head->src_port >= 65535) {
printf("Error: block \"%s\" has incorrect src port\n", head->name);
return NULL;
}
return head;
}
struct matcher_entry *parse_matchers_file(char *matcher_file_path)
{
FILE *matcher_file;
char matcher_line[MATCHER_MAX_LEN];
struct matcher_entry *head = NULL;
int line_no = 0;
matcher_file = fopen(matcher_file_path, "r");
if(matcher_file == NULL) {
perror("fopen");
return NULL;
}
while(fgets(matcher_line, MATCHER_MAX_LEN, matcher_file) != NULL) {
char command[64] = {0};
char *argument, *ptr;
const char *errptr;
int arglen, lenread=0;
int c, fd;
#ifdef HAVE_PYTHON
int pyinitialized=0;
#endif
struct stat statbuf;
line_no++;
matcher_line[MATCHER_MAX_LEN - 1] = 0;
sscanf(matcher_line, "%64s", command);
if(command[0] == 0 || command[0] == '#') {
continue;
}
argument = matcher_line + strlen(command);
// skip over any whitespace
while(*argument == 0x20 || *argument == 0x09) {
argument++;
}
arglen = strlen(argument);
// truncate any new-lines etc
for(ptr = argument + arglen -1; ptr > argument ; ptr--) {
if(*ptr == '\n' || *ptr == '\r') {
*ptr = 0;
}
}
// start parsing commands
if(strcmp(command, "begin") == 0) {
struct matcher_entry *tmp = malloc(sizeof(struct matcher_entry));
if(tmp == NULL) {
perror("malloc");
return NULL;
}
// need to zero this struct
bzero(tmp, sizeof(struct matcher_entry));
tmp->next = head;
head = tmp;
strncpy(head->name, argument, sizeof(head->name));
} else {
if(head == NULL) {
printf("Error in matchers file line %u\n", line_no);
return NULL;
}
if(strcmp(command, "match") == 0) {
// the regex to match
head->match = pcre_compile(argument, PCRE_MULTILINE|PCRE_DOTALL, &errptr, &c, NULL);
if(head->match == NULL) {
printf("Error at character %d in pattern: \"%s\" (%s)\n", c, argument, errptr);
return NULL;
}
} else if(strcmp(command, "ignore") == 0) {
// the regex to ignore
head->ignore = pcre_compile(argument, PCRE_MULTILINE|PCRE_DOTALL, &errptr, &c,NULL);
if(head->ignore == NULL) {
printf("Error at character %d in pattern: \"%s\" (%s)\n", c, argument, errptr);
return NULL;
}
} else if(strcmp(command, "option") == 0) {
if(strcmp(argument, "reset") == 0) {
head->options |= MATCHER_OPTION_RESET;
} else {
printf("Unknown option: %s\n", argument);
return NULL;
}
} else if(strcmp(command, "proto") == 0) {
if(strcmp(argument, "tcp") == 0) {
head->proto = MATCHER_PROTO_TCP;
} else if(strcmp(argument, "udp") == 0) {
head->proto = MATCHER_PROTO_UDP;
} else if(strcmp(argument, "any") == 0) {
head->proto = MATCHER_PROTO_ANY;
} else {
printf("Unknown proto: %s\n", argument);
return NULL;
}
} else if(strcmp(command, "dst_port") == 0) {
head->dst_port = atoi(argument);
} else if(strcmp(command, "src_port") == 0) {
head->src_port = atoi(argument);
} else if(strcmp(command, "response") == 0) {
// path to the file to load the response from
if((fd = open(argument, O_RDONLY)) < 0) {
printf("Error opening file: %s\n", argument);
perror("open");
return NULL;
}
if(fstat(fd, &statbuf) < 0) {
perror("stat");
return NULL;
}
if(statbuf.st_size > MATCHER_MAX_RESPONSE) {
printf("Error: file %s is too large! (Maximum size is %u)\n", argument, MATCHER_MAX_RESPONSE);
return NULL;
}
head->response = malloc(statbuf.st_size + 1);
if(head->response == NULL) {
perror("malloc");
return NULL;
}
while((c = read(fd, head->response + lenread, statbuf.st_size - lenread)) < statbuf.st_size) {
lenread += c;
printf("read %d bytes\n", lenread);
}
lenread += c;
head->response_len = lenread;
#ifdef HAVE_PYTHON
} else if(strcmp(command, "pymodule") == 0) {
if(!pyinitialized) {
setenv("PYTHONPATH", PYTHONPATH, 1);
Py_Initialize();
pyinitialized = 1;
}
PyObject *module = PyImport_Import(PyString_FromString(argument));
if(module == NULL) {
PyErr_Print();
printf("Error loading module: %s\n", argument);
return NULL;
}
head->pyfunc = PyObject_GetAttrString(module, PYFUNCNAME);
if(head->pyfunc == NULL) {
PyErr_Print();
printf("No function named '"PYFUNCNAME"' in module: %s\n", argument);
return NULL;
}
#endif
} else if(strcmp(command, "end") == 0) {
// now's a good time to make sure the block had everything we care about..
if(head && !(head = check_block_params(head))) {
return NULL;
}
} else {
printf("Unknown command at line %u\n", line_no);
return NULL;
}
}
}
return head;
}
void _um_mod_init(char *initargs)
{
const char *name;
char *tmphs, *cwd;
int i;
PyObject *pName, *pTmpObj, *pTmpFunc, *pTmpDict;
GMESSAGE("umpyew init");
if (!strlen(initargs))
{
GERROR("You must specify the Python module name.");
return;
}
name = initargs;
s.name="Prototypal Python bindings for *MView";
s.code=0x07;
s.syscall=(sysfun *)calloc(scmap_scmapsize,sizeof(sysfun));
s.socket=(sysfun *)calloc(scmap_sockmapsize,sizeof(sysfun));
Py_Initialize();
Py_InitModule("umpyew", pEmbMethods);
pEmptyTuple = PyTuple_New(0);
pName = PyString_FromString(name);
cwd = getcwd(NULL, 0);
if (cwd)
{
setenv("PYTHONPATH", cwd, 0);
free(cwd);
}
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (!pModule)
{
GERROR("Error loading Python module %s.\nIt has been searched for in the following path:\n%s", name, getenv("PYTHONPATH"));
PyErr_Print();
return;
}
/*
* Add ctl
*/
if ((ps.ctl = PyObject_GetAttrString(pModule, "modCtl")) && PyCallable_Check(ps.ctl))
s.ctl = ctl;
else
{
GDEBUG(2, "function modCheckFun not defined in module %s", name);
s.ctl = umpyew_alwayszero;
Py_XDECREF(ps.ctl);
}
/*
* Add checkfun
*/
if ((ps.checkfun = PyObject_GetAttrString(pModule, "modCheckFun")) && PyCallable_Check(ps.checkfun))
s.checkfun = checkfun;
else
{
GDEBUG("2, function modCheckFun not defined in module %s", name);
/* This makes the module almost useless, but we respect its author's will. */
s.checkfun = (epoch_t(*)())umpyew_alwayszero;
Py_XDECREF(ps.checkfun);
}
/*
* Add ctlhs
*/
MCH_ZERO(&(s.ctlhs));
pTmpObj = PyObject_GetAttrString(pModule, "modCtlHistorySet");
if (pTmpObj && PyList_Check(pTmpObj))
for (i = 0; i < PyList_Size(pTmpObj); i++)
if ((tmphs = PyString_AsString(PyList_GET_ITEM(pTmpObj, i))))
{
if (!strcmp(tmphs, "proc"))
MCH_SET(MC_PROC, &(s.ctlhs));
else if (!strcmp(tmphs, "module"))
MCH_SET(MC_MODULE, &(s.ctlhs));
else if (!strcmp(tmphs, "mount"))
MCH_SET(MC_MOUNT, &(s.ctlhs));
}
Py_XDECREF(pTmpObj);
/*
* Call modInit, if present
*/
pTmpObj = PyObject_GetAttrString(pModule, "modInit");
if (pTmpObj && PyCallable_Check(pTmpObj))
PyObject_CallObject(pTmpObj, pEmptyTuple);
Py_XDECREF(pTmpObj);
/*
* Add system calls
*/
ps.syscall = calloc(scmap_scmapsize, sizeof(PyObject*));
PYTHON_SYSCALL(open, sysOpen);
PYTHON_SYSCALL(close, sysClose);
PYTHON_SYSCALL(access, sysAccess);
PYTHON_SYSCALL(mkdir, sysMkdir);
PYTHON_SYSCALL(rmdir, sysRmdir);
PYTHON_SYSCALL(chmod, sysChmod);
PYTHON_SYSCALL(chown, sysChown);
PYTHON_SYSCALL(lchown, sysLchown);
PYTHON_SYSCALL(unlink, sysUnlink);
PYTHON_SYSCALL(link, sysLink);
PYTHON_SYSCALL(symlink, sysSymlink);
PYTHON_SYSCALL(stat64, sysStat64);
PYTHON_SYSCALL(lstat64, sysLstat64);
PYTHON_SYSCALL(fstat64, sysFstat64);
PYTHON_SYSCALL(statfs64, sysStatfs64);
PYTHON_SYSCALL(fstatfs64, sysStatfs64);
PYTHON_SYSCALL(readlink, sysReadlink);
PYTHON_SYSCALL(lseek, sysLseek);
PYTHON_SYSCALL(utime, sysUtime);
PYTHON_SYSCALL(utimes, sysUtimes)
PYTHON_SYSCALL(read, sysRead);
PYTHON_SYSCALL(write, sysWrite);
PYTHON_SYSCALL(pread64, sysPread64);
PYTHON_SYSCALL(pwrite64, sysPwrite64);
add_service(&s);
}
virtual void load(const gcore::Path &path, lwc::Registry *reg) {
std::string modulename = path.basename();
modulename = modulename.substr(0, modulename.length()-3);
gcore::Path dirname = path;
dirname.pop();
dirname.makeAbsolute().normalize();
addToSysPath(dirname);
PyObject *pymodname;
pymodname = PyString_FromString(modulename.c_str());
PyObject *mod = PyImport_Import(pymodname);
Py_DECREF(pymodname);
if (!mod) {
std::cout << "pyloader: Could not load python module" << std::endl;
PyErr_Print();
return;
}
PyObject *getCountFunc = PyObject_GetAttrString(mod, "LWC_ModuleGetTypeCount");
if (!getCountFunc || !PyCallable_Check(getCountFunc)) {
if (getCountFunc) {
Py_DECREF(getCountFunc);
}
Py_DECREF(mod);
return;
}
PyObject *getNameFunc = PyObject_GetAttrString(mod, "LWC_ModuleGetTypeName");
if (!getNameFunc || !PyCallable_Check(getNameFunc)) {
Py_DECREF(getCountFunc);
if (getNameFunc) {
Py_DECREF(getNameFunc);
}
Py_DECREF(mod);
return;
}
PyObject *getClassFunc = PyObject_GetAttrString(mod, "LWC_ModuleGetTypeClass");
if (!getClassFunc || !PyCallable_Check(getClassFunc)) {
Py_DECREF(getCountFunc);
Py_DECREF(getNameFunc);
if (getClassFunc) {
Py_DECREF(getClassFunc);
}
Py_DECREF(mod);
return;
}
PyObject *count = PyObject_CallObject(getCountFunc, NULL);
long n = PyInt_AsLong(count);
Py_DECREF(count);
PyObject *args = PyTuple_New(1);
for (long i=0; i<n; ++i) {
// will this DECREF the old index?
PyTuple_SetItem(args, 0, PyInt_FromLong(i));
PyObject *pname = PyObject_CallObject(getNameFunc, args);
PyObject *klass = PyObject_CallObject(getClassFunc, args);
if (!klass) {
std::cout << "pyloader: No class object for type" << std::endl;
continue;
}
char *tn = PyString_AsString(pname);
if (!reg->hasType(tn)) {
if (mFactory->addType(tn, klass)) {
registerType(tn, mFactory, reg);
} else {
std::cout << "pyloader: Invalid type \"" << tn << "\"" << std::endl;
}
} else {
std::cout << "pyloader: Type \"" << tn << "\" already registered" << std::endl;
}
Py_DECREF(pname);
Py_DECREF(klass);
}
Py_DECREF(args);
Py_DECREF(getCountFunc);
Py_DECREF(getNameFunc);
Py_DECREF(getClassFunc);
mPyModules.push_back(mod);
}
int main(int argc, char *argv[]) {
// system("python main.py");
PyObject *pName, *pModule, *pDict, *pFunc, *pArgs, *pValue;
if (argc != 3)
{
printf("Usage: exe_name python_source function_name\n");
return 1;
}
// Initialize the Python Interpreter
Py_Initialize();
// Build the name object
pName = PyString_FromString(argv[1]);
std::cout << argv[1] << std::endl;
PyRun_SimpleString("import sys");
PyRun_SimpleString("import os");
PyRun_SimpleString("print os.getcwd()");
PyRun_SimpleString("sys.path.append(os.getcwd())");
std::cout << "huh?" << std::endl;
// Load the module object
pModule = PyImport_Import(pName);
// pDict is a borrowed reference
pDict = PyModule_GetDict(pModule);
// TODO: Verify module syntax better, otherwise this step can easily fail due to e.g.
//
// FAILS: ./executable my/module myFunc (should be my.module)
// FAILS: No __init__.py in my/ folder
// pFunc is also a borrowed reference
pFunc = PyDict_GetItemString(pDict, argv[2]);
// Process extra parameters
// pArgs = PyTuple_New(1); //argc - 3);
// for (int i=0; i < argc-3; i++) {
// pValue = PyInt_FromLong(atoi(argv[i + 3]));
//
// if (!pValue) {
// PyErr_Print(); return 1; }
//
// PyTuple_SetItem(pArgs, i, pValue);
// }
pArgs = 0;
if (PyCallable_Check(pFunc)) {
pValue = PyObject_CallObject(pFunc, pArgs);
}
else {
PyErr_Print();
Py_DECREF(pValue);
}
// Clean up
Py_DECREF(pModule);
Py_DECREF(pName);
// Py_DECREF(pArgs); // Only needed if it is indeed used
// Finish the Python Interpreter
Py_Finalize();
return 0;
}
/*!
* @brief Prepare the session for use, including all the resources that are embedded.
*/
VOID python_prepare_session()
{
Py_IgnoreEnvironmentFlag = 1;
Py_NoSiteFlag = 1;
Py_Initialize();
PyEval_InitThreads();
PyObject* stdoutModule = Py_InitModule("meterpreter_stdout", meterpreter_stdout_hooks);
if (stdoutModule != NULL && PySys_SetObject("stdout", stdoutModule) == 0)
{
dprintf("[PYTHON] Successfully set the stdout hook");
}
else
{
dprintf("[PYTHON] Failed to set the stdout hook");
}
PyObject* stderrModule = Py_InitModule("meterpreter_stderr", meterpreter_stderr_hooks);
if (stderrModule != NULL && PySys_SetObject("stderr", stderrModule) == 0)
{
dprintf("[PYTHON] Successfully set the stderr hook");
}
else
{
dprintf("[PYTHON] Failed to set the stderr hook");
}
// with the output handlers sorted, we load the stuff from the compressed resource
// which should give us all the stuff we need to be useful.
initerrno();
initnt();
init_socket();
init_functools();
// have we loaded the core pointer already?
if (coreLibPointer == NULL)
{
MEMORY_BASIC_INFORMATION mbi;
if (!VirtualQuery((LPVOID)python_prepare_session, &mbi, sizeof(mbi)))
{
dprintf("[PYTHON] VirtualQuery failed: %d", GetLastError());
return;
}
HMODULE mod = (HMODULE)mbi.AllocationBase;
dprintf("[PYTHON] Module handle: %p", (LPVOID)mod);
HRSRC res = FindResource(mod, MAKEINTRESOURCEA(IDR_PYTHON_CORE), "BINARY");
if (res == NULL)
{
dprintf("[PYTHON] Unable to find resource: %d", GetLastError());
return;
}
HGLOBAL file = LoadResource(mod, res);
if (file == NULL)
{
dprintf("[PYTHON] Unable to load core library resource: %d", GetLastError());
return;
}
// store these pointers for when we reset the session, saves us from
// doing all of this nonsense again.
coreLibPointer = (LPBYTE)LockResource(file);
coreLibSize = *(LPDWORD)coreLibPointer;
coreLibPointer += sizeof(DWORD);
}
dprintf("[PYTHON] coreLibPointer: %p, coreLibSize: %d", coreLibPointer, coreLibSize);
if (coreLibPointer != NULL)
{
// Create a byte array with everything in it
PyObject* libString = PyString_FromStringAndSize(coreLibPointer, coreLibSize);
dprintf("[PYTHON] libString is %p", libString);
// import zlib
PyObject* zlibModStr = PyString_FromString("zlib");
dprintf("[PYTHON] zlibModStr: %p", zlibModStr);
PyObject* zlibMod = PyImport_Import(zlibModStr);
dprintf("[PYTHON] zlibMod: %p", zlibMod);
// get a reference to the decompress function
PyObject* zlibDecompress = PyObject_GetAttrString(zlibMod, "decompress");
dprintf("[PYTHON] zlibDecompress: %p", zlibDecompress);
// prepare arguments for invocation
PyObject* zlibDecompressArgs = PyTuple_Pack(1, libString);
dprintf("[PYTHON] zlibDecompressArgs: %p", zlibDecompressArgs);
// call zlib.decompress(libString)
PyObject* zlibDecompressResult = PyObject_CallObject(zlibDecompress, zlibDecompressArgs);
dprintf("[PYTHON] zlibDecompressResult: %p", zlibDecompressResult);
//dprintf("[PYTHON] zlibDecompressResult type: %s", zlibDecompressResult->ob_type->tp_name);
PCHAR byteArray = NULL;
Py_ssize_t byteArrayLength = 0;
PyString_AsStringAndSize(zlibDecompressResult, &byteArray, &byteArrayLength);
dprintf("[PYTHON] bytes: %p %u", byteArray, byteArrayLength);
PyObject* modData = PyMarshal_ReadObjectFromString(byteArray, byteArrayLength);
dprintf("[PYTHON] modData: %p", modData);
PyObject* mainMod = PyImport_AddModule("__main__");
PyObject* mainDict = PyModule_GetDict(mainMod);
PyModule_AddObject(mainMod, "met_lib_data", modData);
// TODO: double-check that we don't need to remove existing finders which might
// hit the file system
#ifdef DEBUGTRACE
PyRun_SimpleString("eval(met_lib_data[0]);met_init(True)");
#else
PyRun_SimpleString("eval(met_lib_data[0]);met_init(False)");
#endif
// TODO: figure out which reference counts need to be reduce to avoid leaking.
}
// now load the baked-in modules
PyErr_Clear();
for (InitFunc* f = &init_funcs[0]; f->func != NULL; f += 1)
{
dprintf("[PYTHON] Running %s", f->name);
f->func();
if (PyErr_Occurred())
{
#ifdef DEBUGTRACE
PyErr_Print();
#endif
dprintf("[PYTHON] %s errored", f->name);
PyErr_Clear();
}
}
initialize_std_handlers();
binding_init();
}
int NRELPythonApplicInterface::derived_map_ac(const Dakota::String& ac_name)
{
printf ("entered python:derived_map_ac\n");
// probably need to convert all of the following with SWIG or Boost!!
// (there is minimal error checking for now)
// need to cleanup ref counts on Python objects
int fail_code = 0;
// probably want to load the modules and functions at construction time, incl.
// validation and store the objects for later, but need to resolve use of
// analysisDriverIndex
// for now we presume a single analysis component containing module:function
const std::string& an_comp = analysisComponents[analysisDriverIndex][0];
size_t pos = an_comp.find(":");
std::string module_name = an_comp.substr(0,pos);
std::string function_name = an_comp.substr(pos+1);
printf ("importing the module %s\n", module_name.c_str());
// import the module and function and test for callable
PyObject *pModule = PyImport_Import(PyString_FromString(module_name.c_str()));
if (pModule == NULL) {
Cerr << "Error (Direct:Python): Failure importing module " << module_name
<< ".\n Consider setting PYTHONPATH."
<< std::endl;
abort_handler(-1);
}
printf ("imported the module\n");
// Microsoft compiler chokes on this:
// char fn[function_name.size()+1];
char *fn = new char[function_name.size()+1];
strcpy(fn, function_name.c_str());
PyObject *pFunc = PyObject_GetAttrString(pModule, fn);
if (!pFunc || !PyCallable_Check(pFunc)) {
Cerr << "Error (Direct:Python): Function " << function_name << "not found "
<< "or not callable" << std::endl;
abort_handler(-1);
}
delete fn;
// must use empty tuple here to pass to function taking only kwargs
PyObject *pArgs = PyTuple_New(0);
PyObject *pDict = PyDict_New();
// convert DAKOTA data types to Python objects (lists and/or numpy arrays)
PyObject *cv, *cv_labels, *div, *div_labels, *drv, *drv_labels,
*av, *av_labels, *asv, *dvv;
python_convert(xC, &cv);
python_convert(xCLabels, &cv_labels);
python_convert_int(xDI, xDI.length(), &div);
python_convert(xDILabels, &div_labels);
python_convert(xDR, &drv);
python_convert(xDRLabels, &drv_labels);
python_convert(xC, xDI, xDR, &av);
python_convert(xCLabels, xDILabels, xDRLabels, &av_labels);
python_convert_int(directFnASV, directFnASV.size(), &asv);
python_convert_int(directFnDVV, directFnASV.size(), &dvv);
// TO DO: analysis components
// assemble everything into a dictionary to pass to user function
// this should eat references to the objects declared above
PyDict_SetItem(pDict, PyString_FromString("variables"),
PyInt_FromLong((long) numVars));
PyDict_SetItem(pDict, PyString_FromString("functions"),
PyInt_FromLong((long) numFns));
PyDict_SetItem(pDict, PyString_FromString("cv"), cv);
PyDict_SetItem(pDict, PyString_FromString("cv_labels"), cv_labels);
PyDict_SetItem(pDict, PyString_FromString("div"), div);
PyDict_SetItem(pDict, PyString_FromString("div_labels"), div_labels);
PyDict_SetItem(pDict, PyString_FromString("drv"), drv);
PyDict_SetItem(pDict, PyString_FromString("drv_labels"), drv_labels);
PyDict_SetItem(pDict, PyString_FromString("av"), av);
PyDict_SetItem(pDict, PyString_FromString("av_labels"), av_labels);
PyDict_SetItem(pDict, PyString_FromString("asv"), asv);
PyDict_SetItem(pDict, PyString_FromString("dvv"), dvv);
// Does not appear to exist in Windows version of Dakota, and I don't recall using it:
// PyDict_SetItem(pDict, PyString_FromString("fnEvalId"),
// PyInt_FromLong((long) fnEvalId));
///////
///PyDict_SetItem(pDict, PyString_FromString("data"), gData);
printf ("I have data at : %lx, NOW WHAT do I do!?\n", pUserData);
///////
bp::object * tmp2 = NULL;
if (pUserData != NULL)
{
printf ("Setting raw PyObject in dict\n");
tmp2 = (bp::object*)pUserData;
PyDict_SetItem(pDict, PyString_FromString("user_data"),
tmp2->ptr());
}
else
printf("no data\n");
// perform analysis
if (outputLevel > NORMAL_OUTPUT)
Cout << "Info (Direct:Python): Calling function " << function_name
<< " in module " << module_name << "." << std::endl;
PyObject *retVal = PyObject_Call(pFunc, pArgs, pDict);
Py_DECREF(pDict);
Py_DECREF(pArgs);
Py_DECREF(pFunc);
Py_DECREF(pModule);
if (!retVal) {
// TODO: better error reporting from Python
Cerr << "Error (Direct:Python): Unknown error evaluating python "
<< "function." << std::endl;
abort_handler(-1);
}
bool fn_flag = false;
for (int i=0; i<numFns; ++i)
if (directFnASV[i] & 1) {
fn_flag = true;
break;
}
// process return type as dictionary, else assume list of functions only
if (PyDict_Check(retVal)) {
// or the user may return a dictionary containing entires fns, fnGrads,
// fnHessians, fnLabels, failure (int)
// fnGrads, e.g. is a list of lists of doubles
// this is where Boost or SWIG could really help
// making a lot of assumptions on types being returned
PyObject *obj;
if (fn_flag) {
if ( !(obj = PyDict_GetItemString(retVal, "fns")) ) {
Cerr << "Python dictionary must contain list 'fns'" << std::endl;
Py_DECREF(retVal);
abort_handler(-1);
}
if (!python_convert(obj, fnVals, numFns)) {
Py_DECREF(retVal);
abort_handler(-1);
}
}
if (gradFlag) {
if ( !(obj = PyDict_GetItemString(retVal, "fnGrads")) ) {
Cerr << "Python dictionary must contain list 'fnGrads'" << std::endl;
Py_DECREF(retVal);
abort_handler(-1);
}
if (!python_convert(obj, fnGrads)) {
Py_DECREF(retVal);
abort_handler(-1);
}
}
if (hessFlag) {
if ( !(obj = PyDict_GetItemString(retVal, "fnHessians")) ) {
Cerr << "Python dictionary must contain list 'fnHessians'" << std::endl;
Py_DECREF(retVal);
abort_handler(-1);
}
if (!python_convert(obj, fnHessians)){
Py_DECREF(retVal);
abort_handler(-1);
}
}
// optional returns
if (obj = PyDict_GetItemString(retVal, "failure"))
fail_code = PyInt_AsLong(obj);
if (obj = PyDict_GetItemString(retVal, "fnLabels")) {
if (!PyList_Check(obj) || PyList_Size(obj) != numFns) {
Cerr << "'fnLabels' must be list of length numFns." << std::endl;
Py_DECREF(retVal);
abort_handler(-1);
}
for (int i=0; i<numFns; ++i)
fnLabels[i] = PyString_AsString(PyList_GetItem(obj, i));
}
}
else {
// asssume list/numpy array containing only functions
if (fn_flag)
python_convert(retVal, fnVals, numFns);
}
Py_DECREF(retVal);
return(fail_code);
}
