int t_unref( struct sip_msg* p_msg )
{
enum kill_reason kr;
if (T==T_UNDEFINED || T==T_NULL_CELL)
return -1;
if (p_msg->first_line.type==SIP_REQUEST){
kr=get_kr();
if (kr==0
||(p_msg->REQ_METHOD==METHOD_ACK && !(kr & REQ_RLSD))) {
LOG(L_WARN, "WARNING: script writer didn't release transaction\n");
t_release_transaction(T);
}
}
UNREF( T );
set_t(T_UNDEFINED);
return 1;
}
/// Test routine called when an otherwise-unclaimed NetIO packet is received.
gboolean
gotnetpkt(Listener* l, ///<[in/out] Input GSource
FrameSet* fs, ///<[in/out] @ref FrameSet "FrameSet"s received
NetAddr* srcaddr ///<[in] Source address of this packet
)
{
(void)l; (void)srcaddr;
++wirepktcount;
switch(fs->fstype) {
case FRAMESETTYPE_HBDEAD:
g_message("CMA Received dead host notification (type %d) over the 'wire'."
, fs->fstype);
break;
case FRAMESETTYPE_SWDISCOVER:
g_message("CMA Received switch discovery data (type %d) over the 'wire'."
, fs->fstype);
break;
case FRAMESETTYPE_JSDISCOVERY:
g_message("CMA Received JSON discovery data (type %d) over the 'wire'."
, fs->fstype);
check_JSON(fs);
break;
case FRAMESETTYPE_RSCOPREPLY:
g_message("CMA Received resource operation data (type %d) over the 'wire'."
, fs->fstype);
check_JSON(fs);
break;
default:{
char * fsstr = fs->baseclass.toString(&fs->baseclass);
g_message("CMA Received a FrameSet of type %d [%s] over the 'wire'."
, fs->fstype, fsstr);
FREE(fsstr); fsstr = NULL;
}
}
l->transport->_netio->ackmessage(l->transport->_netio, srcaddr, fs);
UNREF(fs);
if (wirepktcount >= maxpkts) {
g_message("QUITTING NOW - wirepktcount!");
nano_initiate_shutdown();
return FALSE;
}
return TRUE;
}
inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
{
struct cell *ret;
if (msg->REQ_METHOD==METHOD_CANCEL) {
ret = t_lookupOriginalT( msg );
DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
if (ret != T_NULL_CELL) {
/* The cell is reffed by t_lookupOriginalT, but T is not set.
So we must unref it before returning. */
UNREF(ret);
set_t(T_UNDEFINED);
return 1;
}
set_t(T_UNDEFINED);
} else {
LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
}
return -1;
}
/**
* FILE_RmDir callback. Recursively destroys the directory contents
*/
STATIC Bool RmDirCB(Str dir, Str fname, void * ctx)
{
Bool ok = False;
StrBuf64 path;
UNREF(ctx);
STRBUF_InitBufXXX(&path);
if (STRBUF_Copy(&path.sb, dir) &&
STRBUF_AppendChar(&path.sb, FILE_SEPARATOR_CHAR) &&
STRBUF_Append(&path.sb, fname)) {
ok = True;
if (FILE_IsDir(path.sb.s)) {
FILE_RmDir(path.sb.s, True);
} else {
FILE_Delete(path.sb.s);
}
}
STRBUF_Destroy(&path.sb);
return ok;
}
const StringId ServerIntangibleObjectTemplate::_SchematicAttribute::getName(bool versionOk, bool testData) const
{
#ifdef _DEBUG
StringId testDataValue = DefaultStringId;
#else
UNREF(testData);
#endif
const ServerIntangibleObjectTemplate::_SchematicAttribute * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerIntangibleObjectTemplate::_SchematicAttribute *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getName(true);
#endif
}
if (!m_name.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter name in template %s", DataResource::getName()));
return DefaultStringId;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter name has not been defined in template %s!", DataResource::getName()));
return base->getName(versionOk);
}
}
const StringId value = m_name.getValue();
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerIntangibleObjectTemplate::_SchematicAttribute::getName
ServerIntangibleObjectTemplate::IngredientType ServerIntangibleObjectTemplate::_Ingredient::getIngredientType(bool versionOk, bool testData) const
{
#ifdef _DEBUG
ServerIntangibleObjectTemplate::IngredientType testDataValue = static_cast<ServerIntangibleObjectTemplate::IngredientType>(0);
#else
UNREF(testData);
#endif
const ServerIntangibleObjectTemplate::_Ingredient * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getIngredientType(true);
#endif
}
if (!m_ingredientType.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter ingredientType in template %s", DataResource::getName()));
return static_cast<IngredientType>(0);
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter ingredientType has not been defined in template %s!", DataResource::getName()));
return base->getIngredientType(versionOk);
}
}
IngredientType value = static_cast<IngredientType>(m_ingredientType.getValue());
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerIntangibleObjectTemplate::_Ingredient::getIngredientType
const std::string & SharedShipObjectTemplate::getInteriorLayoutFileName(bool testData) const
{
#ifdef _DEBUG
std::string testDataValue = DefaultString;
#else
UNREF(testData);
#endif
const SharedShipObjectTemplate * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const SharedShipObjectTemplate *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getInteriorLayoutFileName(true);
#endif
}
if (!m_interiorLayoutFileName.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter interiorLayoutFileName in template %s", DataResource::getName()));
return DefaultString;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter interiorLayoutFileName has not been defined in template %s!", DataResource::getName()));
return base->getInteriorLayoutFileName();
}
}
const std::string & value = m_interiorLayoutFileName.getValue();
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // SharedShipObjectTemplate::getInteriorLayoutFileName
inline static int t_check_trans(struct sip_msg* msg)
{
struct cell *trans;
if (msg->REQ_METHOD==METHOD_CANCEL) {
/* parse needed hdrs*/
if (check_transaction_quadruple(msg)==0) {
LM_ERR("too few headers\n");
return 0; /*drop request!*/
}
if (!msg->hash_index)
msg->hash_index = tm_hash(msg->callid->body,get_cseq(msg)->number);
/* performe lookup */
trans = t_lookupOriginalT( msg );
return trans?1:-1;
} else {
trans = get_t();
if (trans==NULL)
return -1;
if (trans!=T_UNDEFINED)
return 1;
switch ( t_lookup_request( msg , 0) ) {
case 1:
/* transaction found -> is it local ACK? */
if (msg->REQ_METHOD==METHOD_ACK)
return 1;
/* .... else -> retransmission */
trans = get_t();
t_retransmit_reply(trans);
UNREF(trans);
set_t(0);
return 0;
case -2:
/* e2e ACK found */
return 1;
default:
/* notfound */
return -1;
}
}
}
//@BEGIN TFD
const std::string & ServerManufactureSchematicObjectTemplate::getDraftSchematic(bool testData) const
{
#ifdef _DEBUG
std::string testDataValue = DefaultString;
#else
UNREF(testData);
#endif
const ServerManufactureSchematicObjectTemplate * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerManufactureSchematicObjectTemplate *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getDraftSchematic(true);
#endif
}
if (!m_draftSchematic.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter draftSchematic in template %s", DataResource::getName()));
return DefaultString;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter draftSchematic has not been defined in template %s!", DataResource::getName()));
return base->getDraftSchematic();
}
}
const std::string & value = m_draftSchematic.getValue();
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerManufactureSchematicObjectTemplate::getDraftSchematic
bool SharedShipObjectTemplate::getPlayerControlled(bool testData) const
{
#ifdef _DEBUG
bool testDataValue = false;
#else
UNREF(testData);
#endif
const SharedShipObjectTemplate * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const SharedShipObjectTemplate *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getPlayerControlled(true);
#endif
}
if (!m_playerControlled.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter playerControlled in template %s", DataResource::getName()));
return false;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter playerControlled has not been defined in template %s!", DataResource::getName()));
return base->getPlayerControlled();
}
}
bool value = m_playerControlled.getValue();
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // SharedShipObjectTemplate::getPlayerControlled
const std::string & ServerIntangibleObjectTemplate::_Ingredient::getSkillCommand(bool versionOk, bool testData) const
{
#ifdef _DEBUG
std::string testDataValue = DefaultString;
#else
UNREF(testData);
#endif
const ServerIntangibleObjectTemplate::_Ingredient * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getSkillCommand(true);
#endif
}
if (!m_skillCommand.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter skillCommand in template %s", DataResource::getName()));
return DefaultString;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter skillCommand has not been defined in template %s!", DataResource::getName()));
return base->getSkillCommand(versionOk);
}
}
const std::string & value = m_skillCommand.getValue();
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerIntangibleObjectTemplate::_Ingredient::getSkillCommand
/**
* Writes the ending of a class header file.
*
* @param fp the file to write to
* @param sourceTemplate the template we are writing code for
*/
void TemplateDefinitionFile::writeClassHeaderEnd(File &fp, const TemplateData & sourceTemplate) const
{
UNREF(sourceTemplate);
const char *name = getTemplateName().c_str();
fp.print("\n");
fp.print("private:\n");
fp.print("\tTag m_templateVersion;\t// the template version\n");
fp.print("\tbool m_versionOk;\t// flag that the template version loaded is "
"the one we expect\n");
if (!m_writeForCompilerFlag)
fp.print("\tstatic bool ms_allowDefaultTemplateParams;\t// flag to allow defaut params instead of fataling\n");
fp.print("\n");
fp.print("\tstatic void registerMe(void);\n");
fp.print("\tstatic ObjectTemplate * create(const std::string & filename);\n");
fp.print("\n");
fp.print("\t// no copying\n");
fp.print("\t%s(const %s &);\n", name, name);
fp.print("\t%s & operator =(const %s &);\n", name, name);
fp.print("};\n");
fp.print("\n");
fp.print("\n");
if (m_writeForCompilerFlag)
{
fp.print("inline void %s::install(void)\n", name);
fp.print("{\n");
}
else
{
fp.print("inline void %s::install(bool allowDefaultTemplateParams)\n", name);
fp.print("{\n");
fp.print("\tms_allowDefaultTemplateParams = allowDefaultTemplateParams;\n");
}
sourceTemplate.writeRegisterTemplate(fp, "\t");
fp.print("}\n");
fp.print("\n");
fp.print("\n");
fp.print("#endif\t// _INCLUDED_%s_H\n", name);
} // TemplateDefinitionFile::writeClassHeaderEnd
void loadDataTables()
{
FILE* fp = fopen("datatables.plf","r");
char buf [256];
if (fp)
{
DEBUG_REPORT_LOG(true, ("Scanning tables"));
char* line = fgets(buf, 256, fp);
while (line)
{
//strip newline
int len = strlen(line);
for (int i = len - 1; i > 0; --i)
{
if (buf[i] == '\n')
{
buf[i] = 0;
break;
}
}
char* tmp = strstr(buf, "datatables/");
if (tmp)
line = tmp;
DataTable* dt = DataTableManager::getTable(line, true);
#if 0
if (dt)
ms_dataTableList.push_back(dt);
#else
UNREF(dt);
#endif
DEBUG_REPORT_LOG(true, ("."));
line = fgets(buf, 256, fp);
}
fclose(fp);
DEBUG_REPORT_LOG(true, ("\n"));
}
}
gboolean
workspace_load_compat( Workspace *ws, int major, int minor )
{
char pathname[FILENAME_MAX];
GSList *path;
int best_major;
int best_minor;
if( workspace_have_compat( major, minor, &best_major, &best_minor ) ) {
/* Make a private toolkitgroup local to this workspace to
* hold the compatibility defs we are planning to load.
*/
UNREF( ws->kitg );
ws->kitg = toolkitgroup_new( ws->sym );
g_object_ref( G_OBJECT( ws->kitg ) );
iobject_sink( IOBJECT( ws->kitg ) );
im_snprintf( pathname, FILENAME_MAX,
"$VIPSHOME/share/" PACKAGE "/compat/%d.%d",
best_major, best_minor );
path = path_parse( pathname );
if( path_map( path, "*.def",
(path_map_fn) workspace_load_toolkit, ws->kitg ) ) {
path_free2( path );
return( FALSE );
}
path_free2( path );
ws->compat_major = best_major;
ws->compat_minor = best_minor;
}
else {
/* No compat defs necessary for this ws.
*/
ws->compat_major = 0;
ws->compat_minor = 0;
}
return( TRUE );
}
/* fifo command to cancel a pending call (Uli)
* Syntax:
*
* ":uac_cancel:[response file]\n
* callid\n
* cseq\n
*/
void rpc_cancel(rpc_t* rpc, void* c)
{
struct cell *trans;
static char cseq[128], callid[128];
struct cancel_info cancel_data;
int i,j;
str cseq_s; /* cseq */
str callid_s; /* callid */
cseq_s.s=cseq;
callid_s.s=callid;
init_cancel_info(&cancel_data);
if (rpc->scan(c, "SS", &callid_s, &cseq_s) < 2) {
rpc->fault(c, 400, "Callid and CSeq expected as parameters");
return;
}
if( t_lookup_callid(&trans, callid_s, cseq_s) < 0 ) {
DBG("Lookup failed\n");
rpc->fault(c, 400, "Transaction not found");
return;
}
/* find the branches that need cancel-ing */
prepare_to_cancel(trans, &cancel_data.cancel_bitmap, 0);
/* tell tm to cancel the call */
DBG("Now calling cancel_uacs\n");
i=cancel_uacs(trans, &cancel_data, 0); /* don't fake 487s,
just wait for timeout */
/* t_lookup_callid REF`d the transaction for us, we must UNREF here! */
UNREF(trans);
j=0;
while(i){
j++;
i&=i-1;
}
rpc->add(c, "ds", j, "branches remaining (waiting for timeout)");
}
void JNICALL ScriptMethodsChatNamespace::chatSendSystemMessage(JNIEnv * env, jobject self, jstring _to, jstring _message, jstring _oob)
{
UNREF(self);
if (!_to)
return;
Unicode::String to;
{
const JavaStringParam jt(_to);
if(!JavaLibrary::convert(jt, to))
return;
}
Unicode::String message;
if (_message)
{
const JavaStringParam jt(_message);
if (!JavaLibrary::convert(jt, message))
return;
}
Unicode::String oob;
if (_oob)
{
const JavaStringParam jt(_oob);
if (!JavaLibrary::convert(jt, oob))
return;
}
if (message.empty () && oob.empty ())
{
DEBUG_WARNING (true, ("chatSendSystemMessage with empty message _and_ oob"));
}
Chat::sendSystemMessage(Unicode::wideToNarrow (to), message, oob);
}
/**
* "End element" callback for XML_Handle. If this tag has been "skipped" by
* XML_StartElemCB, simply decrements skipDepth. Otherwise, calls the client
* callback to deallocate the tag context.
*/
STATIC void XML_HandleEndElem(void * ctx, Str tag)
{
XMLContext * context = (XMLContext*)ctx;
UNREF(tag);
if (context->error && context->skipDepth > 0) {
context->skipDepth--;
} else {
int depth = VECTOR_Size(&context->stack);
ASSERT(depth > 0);
if (depth == 1 && !context->error) {
XMLTagCtx * root;
root = (XMLTagCtx*)VECTOR_Get(&context->stack,0);
ASSERT(root && root->context == context);
ASSERT(!context->rootTag);
/* prevent XML_VectorFreeTagContext from deallocating the tag */
context->rootTag = root->tag;
root->tag = NULL;
}
if (depth > 0) {
VECTOR_Remove(&context->stack, depth-1);
}
}
}
/**
* Saves the template data to an iff file.
*
* @param file file to save to
* @param location file type (client or server)
*/
void ServerStaticObjectTemplate::save(Iff &file)
{
int count;
file.insertForm(ServerStaticObjectTemplate_tag);
if (m_baseTemplateName.size() != 0)
{
file.insertForm(TAG(D,E,R,V));
file.insertChunk(TAG(X, X, X, X));
file.insertChunkData(m_baseTemplateName.c_str(), m_baseTemplateName.size() + 1);
file.exitChunk();
file.exitForm();
}
file.insertForm(TAG(0,0,0,1));
file.allowNonlinearFunctions();
int paramCount = 0;
// save clientOnlyBuildout
file.insertChunk(TAG(X, X, X, X));
file.insertChunkString("clientOnlyBuildout");
m_clientOnlyBuildout.saveToIff(file);
file.exitChunk();
++paramCount;
// write number of parameters
file.goToTopOfForm();
file.insertChunk(TAG(P, C, N, T));
file.insertChunkData(¶mCount, sizeof(paramCount));
file.exitChunk();
file.exitForm(true);
ServerObjectTemplate::save(file);
file.exitForm();
UNREF(count);
} // ServerStaticObjectTemplate::save
/// Finalizing function for Discovery objects
FSTATIC void
_discovery_finalize(AssimObj* gself) ///<[in/out] Object to finalize (free)
{
Discovery* self = CASTTOCLASS(Discovery, gself);
char * instancename = self->_instancename;
if (self->_timerid > 0) {
g_source_remove(self->_timerid);
self->_timerid = 0;
}
if (self->_config) {
UNREF(self->_config);
}
if (_discovery_timers && instancename) {
self->_instancename = NULL; // Avoid infinite recursion...
g_hash_table_remove(_discovery_timers, instancename);
}
if (instancename) {
g_free(instancename);
self->_instancename = instancename = NULL;
}
FREECLASSOBJ(self); self=NULL;
}
/**
* Loads the template data from an iff file. We should already be in the form
* for this template.
*
* @param file file to load from
*/
void ServerManufactureSchematicObjectTemplate::_IngredientSlot::load(Iff &file)
{
static const int MAX_NAME_SIZE = 256;
char paramName[MAX_NAME_SIZE];
file.enterForm();
file.enterChunk();
int paramCount = file.read_int32();
file.exitChunk();
for (int i = 0; i < paramCount; ++i)
{
file.enterChunk();
file.read_string(paramName, MAX_NAME_SIZE);
if (strcmp(paramName, "name") == 0)
m_name.loadFromIff(file);
else if (strcmp(paramName, "ingredient") == 0)
m_ingredient.loadFromIff(file);
file.exitChunk(true);
}
file.exitForm();
UNREF(file);
} // ServerManufactureSchematicObjectTemplate::_IngredientSlot::load
/// Append a ResourceQuee
FSTATIC gboolean
_resource_queue_Qcmd(ResourceQueue* self
, ConfigContext* request
, ResourceCmdCallback callback
, gpointer user_data)
{
ResourceCmd* cmd;
gboolean ret;
// Will replace NULL with our qelem object
cmd = resourcecmd_new(request, NULL, _resource_queue_endnotify);
if (cmd == NULL) {
if (callback) {
callback(request, user_data, EXITED_INVAL
, 0, 0, FALSE, "Invalid Arguments");
}
return FALSE;
}
ret = _resource_queue_cmd_append(self, cmd, callback, user_data);
UNREF(cmd);
return ret;
}
/**
* Loads the template data from an iff file. We should already be in the form
* for this template.
*
* @param file file to load from
*/
void ServerIntangibleObjectTemplate::_SchematicAttribute::load(Iff &file)
{
static const int MAX_NAME_SIZE = 256;
char paramName[MAX_NAME_SIZE];
file.enterForm();
file.enterChunk();
int paramCount = file.read_int32();
file.exitChunk();
for (int i = 0; i < paramCount; ++i)
{
file.enterChunk();
file.read_string(paramName, MAX_NAME_SIZE);
if (strcmp(paramName, "name") == 0)
m_name.loadFromIff(file);
else if (strcmp(paramName, "value") == 0)
m_value.loadFromIff(file);
file.exitChunk(true);
}
file.exitForm();
UNREF(file);
} // ServerIntangibleObjectTemplate::_SchematicAttribute::load
float ServerIntangibleObjectTemplate::_Ingredient::getComplexityMax(bool versionOk, bool testData) const
{
#ifdef _DEBUG
float testDataValue = 0.0f;
#else
UNREF(testData);
#endif
const ServerIntangibleObjectTemplate::_Ingredient * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getComplexityMax(true);
#endif
}
if (!m_complexity.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter complexity in template %s", DataResource::getName()));
return 0.0f;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter complexity has not been defined in template %s!", DataResource::getName()));
return base->getComplexityMax(versionOk);
}
}
float value = m_complexity.getMaxValue();
char delta = m_complexity.getDeltaType();
if (delta == '+' || delta == '-' || delta == '_' || delta == '=')
{
float baseValue = 0;
if (m_baseData != NULL)
{
if (base != NULL)
baseValue = base->getComplexityMax(versionOk);
else if (ms_allowDefaultTemplateParams)
DEBUG_WARNING(true, ("No base template for delta, using 0"));
else
NOT_NULL(base);
}
if (delta == '+')
value = baseValue + value;
else if (delta == '-')
value = baseValue - value;
else if (delta == '=')
value = baseValue + static_cast<float>(baseValue * (value / 100.0f));
else if (delta == '_')
value = baseValue - static_cast<float>(baseValue * (value / 100.0f));
}
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerIntangibleObjectTemplate::_Ingredient::getComplexityMax
/**
* @ref ChildProcess constructor.
* Here's what we're going to do:
* 1) Create child process using g_spawn_async_with_pipes()
* 2) ...In child process become our own process group
* 3) Create LogSourceFd object for stderr
* 4) Create LogSourceFd or GMainFd object for stdout
* 5) Set timer (if any)
* 6) Initialize the child state to running
* 7) Return.
*/
WINEXPORT ChildProcess*
childprocess_new(gsize cpsize ///< Size of created ChildProcess object
, char** argv ///< NULL-terminated argv for the ChildProcess
, const char** envp ///< Environment for the ChildProcess
, ConfigContext* envmod ///< Modifications to the ChildProcess environment
, const char* curdir ///< Current directory to start the child in
, void (*notify)(ChildProcess*, enum HowDied, int rc, int signal, gboolean core_dumped)
///< Function to call if/when the child terminates
, gboolean save_stdout ///< TRUE to save stdout, FALSE to log it
, const char*logdomain ///< Glib log domain
, const char*logprefix ///< Prefix to prepend to log entries
, GLogLevelFlags loglevel ///< Glib Log level
, guint32 timeout_seconds ///< How long to wait before killing it - zero for no timeout
, gpointer user_data ///< Data our user wants us to keep
, enum ChildErrLogMode logmode ///< How to log child exits
, const char* logname) ///< Name to use when logging child exits as requested
{
AssimObj* aself;
ChildProcess* self;
gint stdoutfd;
gint stderrfd;
GError* failcode = NULL;
gchar** childenv = NULL;
BINDDEBUG(ChildProcess);
g_return_val_if_fail(logprefix != NULL, NULL);
if (cpsize < sizeof(ChildProcess)) {
cpsize = sizeof(ChildProcess);
}
aself = assimobj_new(cpsize);
g_return_val_if_fail(aself != NULL, NULL);
self = NEWSUBCLASS(ChildProcess, aself);
childenv = assim_merge_environ(envp, envmod);
if (!g_spawn_async_with_pipes(
curdir, // Current directory
argv, // Arguments
childenv, // environment
G_SPAWN_DO_NOT_REAP_CHILD, // GSpawnFlags flags,
_childprocess_setup_child, // GSpawnChildSetupFunc child_setup,
self, // gpointer user_data,
&self->child_pid, // GPid *child_pid,
NULL, // gint *standard_input,
&stdoutfd, // gint *standard_output,
&stderrfd, // gint *standard_error,
&failcode)) { // GError **error
// OOPS! Failed!
const char * msg = "unknown exec error";
if (failcode && failcode->message) {
msg = failcode->message;
}
g_critical("%s.%d: %s", __FUNCTION__, __LINE__, msg);
if (failcode) {
g_clear_error(&failcode); // sets failcode back to NULL
}
assim_free_environ(childenv); childenv = NULL;
UNREF(self);
aself = NULL;
return NULL;
}
DEBUGMSG2("%s.%d: Spawned process with user_data = %p", __FUNCTION__, __LINE__, self);
aself->_finalize = _childprocess_finalize;
aself->toString = _childprocess_toString;
self->stderr_src = logsourcefd_new(0, stderrfd, G_PRIORITY_HIGH, g_main_context_default()
, logdomain, loglevel, logprefix);
self->user_data = user_data;
self->logmode = logmode;
if (NULL == logname) {
logname = argv[0];
}
self->loggingname = g_strdup(logname);
assim_free_environ(childenv);
childenv = NULL;
if (!save_stdout) {
LogSourceFd* logsrc;
logsrc = logsourcefd_new(0, stdoutfd, G_PRIORITY_HIGH
, g_main_context_default(), logdomain, loglevel, logprefix);
self->stdout_src = &logsrc->baseclass;
}else{
self->stdout_src = gmainfd_new(0, stdoutfd, G_PRIORITY_HIGH, g_main_context_default());
}
self->childsrc_id = g_child_watch_add(self->child_pid, _childprocess_childexit, self);
self->notify = notify;
if (0 == timeout_seconds) {
DEBUGMSG2("No timeout for process with user_data = %p", self);
self->timeoutsrc_id = 0;
}else{
self->timeoutsrc_id = g_timeout_add_seconds(timeout_seconds
, _childprocess_timeout, self);
DEBUGMSG3("%s.%d: Set %d second timeout %d for process with user_data = %p"
, __FUNCTION__, __LINE__, timeout_seconds, self->timeoutsrc_id, self);
}
self->child_state = CHILDSTATE_RUNNING;
DEBUGMSG5("%s.%d: REF child: %p", __FUNCTION__,__LINE__, self);
REF(self); // We do this because we need to still be here when the process exits
return self;
}
int ServerIntangibleObjectTemplate::_SchematicAttribute::getValueMin(bool versionOk, bool testData) const
{
#ifdef _DEBUG
int testDataValue = 0;
#else
UNREF(testData);
#endif
const ServerIntangibleObjectTemplate::_SchematicAttribute * base = NULL;
if (m_baseData != NULL)
{
base = dynamic_cast<const ServerIntangibleObjectTemplate::_SchematicAttribute *>(m_baseData);
#ifdef _DEBUG
if (testData && base != NULL)
testDataValue = base->getValueMin(true);
#endif
}
if (!m_value.isLoaded())
{
if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL)
{
DEBUG_WARNING(true, ("Returning default value for missing parameter value in template %s", DataResource::getName()));
return 0;
}
else
{
DEBUG_FATAL(base == NULL, ("Template parameter value has not been defined in template %s!", DataResource::getName()));
return base->getValueMin(versionOk);
}
}
int value = m_value.getMinValue();
char delta = m_value.getDeltaType();
if (delta == '+' || delta == '-' || delta == '_' || delta == '=')
{
int baseValue = 0;
if (m_baseData != NULL)
{
if (base != NULL)
baseValue = base->getValueMin(versionOk);
else if (ms_allowDefaultTemplateParams)
DEBUG_WARNING(true, ("No base template for delta, using 0"));
else
NOT_NULL(base);
}
if (delta == '+')
value = baseValue + value;
else if (delta == '-')
value = baseValue - value;
else if (delta == '=')
value = baseValue + static_cast<int>(baseValue * (value / 100.0f));
else if (delta == '_')
value = baseValue - static_cast<int>(baseValue * (value / 100.0f));
}
#ifdef _DEBUG
if (testData && base != NULL)
{
}
#endif
return value;
} // ServerIntangibleObjectTemplate::_SchematicAttribute::getValueMin
void unref_cell(struct cell *t)
{
UNREF(t);
}
/// Function called when the child (finally) exits...
FSTATIC void
_childprocess_childexit(GPid pid, gint status, gpointer childprocess_object)
{
ChildProcess* self = CASTTOCLASS(ChildProcess, childprocess_object);
gboolean signalled = WIFSIGNALED(status);
int exitrc = 0;
int signal = 0;
gboolean logexit = FALSE;
enum HowDied howwedied = NOT_EXITED;
(void)pid;
if (self->timeoutsrc_id > 0) {
g_source_remove(self->timeoutsrc_id);
DEBUGMSG3("%s.%d: Removed timeout %d for process with user_data = %p"
, __FUNCTION__, __LINE__, self->timeoutsrc_id, self);
self->timeoutsrc_id = 0;
}
// If it refused to die, then the status is invalid
if ((guint)(self->child_state) >= DIMOF(signalmap)) {
howwedied = EXITED_HUNG;
}else if ((guint)self->child_state != CHILDSTATE_RUNNING) {
// Then we tried to kill it...
howwedied = EXITED_TIMEOUT;
signal = signalled ? WTERMSIG(status) : 0;
}else{
if (signalled) {
signal = WTERMSIG(status);
howwedied = EXITED_SIGNAL;
}else{
exitrc = WEXITSTATUS(status);
howwedied = (exitrc == 0 ? EXITED_ZERO : EXITED_NONZERO);
}
}
switch (howwedied) {
case EXITED_SIGNAL: /*FALLTHROUGH*/
case EXITED_TIMEOUT: /*FALLTHROUGH*/
case EXITED_HUNG:
logexit = self->logmode > CHILD_NOLOG;
break;
case EXITED_NONZERO:
logexit = self->logmode >= CHILD_LOGERRS;
break;
case EXITED_ZERO:
logexit = self->logmode >= CHILD_LOGALL;
break;
default:
// We'll never produce any other values above
/*NOTREACHED*/
logexit = TRUE;
break;
}
if (logexit) {
switch (howwedied) {
case EXITED_SIGNAL:
g_warning("Child process [%s] died from signal %d%s."
, self->loggingname, signal, WCOREDUMP(status) ? " (core dumped)" : "");
break;
case EXITED_TIMEOUT:
if (signalled) {
g_warning("Child process [%s] timed out after %d seconds [signal %d%s]."
, self->loggingname, self->timeout, signal
, WCOREDUMP(status) ? " (core dumped)" : "");
}else{
g_warning("Child process [%s] timed out after %d seconds."
, self->loggingname, self->timeout);
}
break;
case EXITED_HUNG:
g_warning("Child process [%s] timed out after %d seconds and could not be killed."
, self->loggingname, self->timeout);
break;
case EXITED_NONZERO:
g_message("Child process [%s] exited with return code %d."
, self->loggingname, exitrc);
break;
case EXITED_ZERO:
g_message("Child process [%s] exited normally.", self->loggingname);
break;
default:/*NOTREACHED*/
break;
}
}
DEBUGMSG2("%s.%d: Exit happened howwedied:%d", __FUNCTION__, __LINE__
, howwedied);
if (!self->stdout_src->atEOF) {
//DEBUGMSG3("Child %d [%s] EXITED but output is not at EOF [fd%d]", pid
//, self->loggingname, self->stdout_src->gfd.fd);
self->stdout_src->readmore(self->stdout_src);
}
if (!self->stderr_src->baseclass.atEOF) {
self->stderr_src->baseclass.readmore(&self->stderr_src->baseclass);
}
self->notify(self, howwedied, exitrc, signal, WCOREDUMP(status));
self->child_state = -1;
DEBUGMSG5("%s.%d: UNREF child: %p", __FUNCTION__,__LINE__, self);
UNREF(self); // Undo the REF(self) in our constructor
}
/* function returns:
* 1 - forward successful
* -1 - error during forward
*/
int t_forward_nonack( struct cell *t, struct sip_msg* p_msg ,
struct proxy_l * proxy, int proto)
{
str backup_uri;
int branch_ret, lowest_ret;
str current_uri;
branch_bm_t added_branches;
int first_branch;
int i, q;
struct cell *t_invite;
int success_branch;
int try_new;
str dst_uri;
/* make -Wall happy */
current_uri.s=0;
set_kr(REQ_FWDED);
if (p_msg->REQ_METHOD==METHOD_CANCEL) {
t_invite=t_lookupOriginalT( p_msg );
if (t_invite!=T_NULL_CELL) {
e2e_cancel( p_msg, t, t_invite );
UNREF(t_invite);
return 1;
}
}
/* backup current uri ... add_uac changes it */
backup_uri = p_msg->new_uri;
/* if no more specific error code is known, use this */
lowest_ret=E_BUG;
/* branches added */
added_branches=0;
/* branch to begin with */
first_branch=t->nr_of_outgoings;
/* on first-time forwarding, use current uri, later only what
is in additional branches (which may be continuously refilled
*/
if (first_branch==0) {
try_new=1;
branch_ret=add_uac( t, p_msg, GET_RURI(p_msg), GET_NEXT_HOP(p_msg), proxy, proto );
if (branch_ret>=0)
added_branches |= 1<<branch_ret;
else
lowest_ret=branch_ret;
} else try_new=0;
init_branch_iterator();
while((current_uri.s=next_branch( ¤t_uri.len, &q, &dst_uri.s, &dst_uri.len))) {
try_new++;
branch_ret=add_uac( t, p_msg, ¤t_uri,
(dst_uri.len) ? (&dst_uri) : ¤t_uri,
proxy, proto);
/* pick some of the errors in case things go wrong;
note that picking lowest error is just as good as
any other algorithm which picks any other negative
branch result */
if (branch_ret>=0)
added_branches |= 1<<branch_ret;
else
lowest_ret=branch_ret;
}
/* consume processed branches */
clear_branches();
/* restore original URI */
p_msg->new_uri=backup_uri;
/* don't forget to clear all branches processed so far */
/* things went wrong ... no new branch has been fwd-ed at all */
if (added_branches==0) {
if (try_new==0) {
LOG(L_ERR, "ERROR: t_forward_nonack: no branched for forwarding\n");
return -1;
}
LOG(L_ERR, "ERROR: t_forward_nonack: failure to add branches\n");
return lowest_ret;
}
/* send them out now */
success_branch=0;
for (i=first_branch; i<t->nr_of_outgoings; i++) {
if (added_branches & (1<<i)) {
if (SEND_BUFFER( &t->uac[i].request)==-1) {
LOG(L_ERR, "ERROR: t_forward_nonack: sending request failed\n");
if (proxy) {
proxy->errors++;
proxy->ok=0;
}
} else {
success_branch++;
}
start_retr( &t->uac[i].request );
}
}
if (success_branch<=0) {
ser_error=E_SEND;
return -1;
}
return 1;
}
/// Constructs a GSList list of @ref FrameSet objects from a datagram/packet.
/// That is, it decodes the datagram/packet.
/// @return GSList of @ref FrameSet object pointers.
GSList*
_pktdata_to_framesetlist(PacketDecoder*self, ///<[in] PacketDecoder object
gpointer pktstart, ///<[in] start of packet
gconstpointer pktend) ///<[in] first byte past end of packet
{
guint8* curframeset = pktstart;
GSList* ret = NULL;
// Loop over all the FrameSets in the packet we were given.
while (curframeset < (guint8*)pktend) {
gpointer nextframeset = NULL;
gpointer framestart = ((guint8*)curframeset + FRAMESET_INITSIZE);
gpointer curframe;
FrameSet* fs;
gconstpointer fsend = pktend;
gpointer newframestart = NULL;
gboolean firstframe = TRUE;
guint32 framesetlen;
// Check the overall frame size
framesetlen = get_generic_tlv_len(curframeset, pktend);
if (framesetlen > (guint32)((guint8*)pktend-(curframeset+FRAMESET_INITSIZE))) {
g_warning("%s.%d: Received frameset length [%d] is invalid - cannot exceed %d"
, __FUNCTION__, __LINE__, framesetlen
, (int)((guint8*)pktend-(curframeset+FRAMESET_INITSIZE)));
goto errout;
}
fsend = curframeset+framesetlen+FRAMESET_INITSIZE;
fs = _decode_packet_get_frameset_data(curframeset, curframeset+framesetlen, &nextframeset);
g_return_val_if_fail(fs != NULL, ret);
if (!is_valid_generic_tlv_packet(framestart, pktend)) {
g_warning("%s.%d: Frameset type %d not a valid TLV frameset"
, __FUNCTION__, __LINE__, fs->fstype);
UNREF(fs);
goto errout;
}
// Construct this FrameSet from the series of frames encoded in the packet.
// Note that two special kinds of frames can alter the packet we're examining.
// This is explained in more detail inside the loop.
curframe = framestart;
while (curframe != NULL && curframe < fsend) {
Frame* newframe;
gpointer newpacket = NULL;
// The first special case frame is the compression frame, in which case the
// remaining packet is replaced by a new, larger (decompressed) packet.
//
// The second type is the encryption packet, in which case the remaining
// packet is replaced by a new chunk of data which will have different
// (decrypted) content, and would normally be expected to be the same size
// as the original.
//
// This means that "decode_packet_framedata_to_frameobject" might replace the
// packet data we've been looking at.
// (FWIW: It's perfectly OK to have an encryption frame followed by a
// (embedded) compression frame -- both kinds can occur in the same FrameSet).
newframe = _decode_packet_framedata_to_frameobject(self, &curframe, &fsend, &newpacket);
if (newpacket) {
if (newframestart != NULL) {
// We did packet replacement more than once...
g_free(newframestart);
}
newframestart = newpacket;
}
if (NULL == newframe) {
UNREF(fs);
goto errout;
}
if (TRUE == firstframe) {
if (!OBJ_IS_A(newframe, "SignFrame")) {
UNREF(newframe);
UNREF(fs);
g_warning("%s.%d: First frame NOT a signature frame - [%d] instead"
, __FUNCTION__, __LINE__, newframe->type);
goto errout;
}
firstframe = FALSE;
}
frameset_append_frame(fs, newframe);
UNREF(newframe);
}
if (curframe != fsend) {
g_warning("%s.%d: Received %d frameset - length is off by"
": %d instead"
, __FUNCTION__, __LINE__, fs->fstype
, (int)((guint8*)fsend-((guint8*)curframe)));
goto errout;
}
if (newframestart) {
g_free(newframestart); newframestart = NULL;
}
if (fs) {
ret = g_slist_append(ret, fs); fs = NULL;
}
curframeset = nextframeset;
}
return ret;
errout:
g_slist_free_full(ret, assim_g_notify_unref); ret = NULL;
return ret;
}
LogObserver *DatabaseLogObserver::create(std::string const &spec)
{
UNREF(spec);
return new DatabaseLogObserver();
}
