bool
JavaJncReader::GetSymbolAndRangeFromAddr(
gtUInt64 addr,
string& symName,
gtUInt64& startAddr,
gtUInt64& endAddr
)
{
bool bRet = false;
// NOTE: This is 1 because the first item in the table is the main
// method for the JNC
//
for (unsigned int i = 1; i < m_addressRangeTable.size(); i++)
{
// Check if address is within the range
if ((addr >= m_addressRangeTable[i].pc_start)
&& (addr <= m_addressRangeTable[i].pc_end))
{
symName = GetMethodName((jmethodID)m_addressRangeTable[i].id);
startAddr = (gtUInt64) m_addressRangeTable[i].pc_start,
endAddr = (gtUInt64) m_addressRangeTable[i].pc_end,
bRet = true;
}
// In case there are duplicate range we use the inner most one
// TODO: Verify this part
if ((addr < m_addressRangeTable[i].pc_start))
{
break;
}
}
return bRet;
}
void HttpRequest::AppendStartLineToString(std::string* result) const {
CHECK_NE(m_method, METHOD_UNKNOWN);
StringAppend(result, GetMethodName(m_method), " ", m_uri);
HttpVersion version = Version();
if (!version.IsEmpty()) {
StringAppend(result, " ", "HTTP/", version.Major(), ".", version.Minor());
}
}
void
JavaJncReader::_fillLineNumSrcMap(
JNCInlineMap& ilmap,
int numFrames,
void* vbcisArray,
void* vmethodArray,
gtUInt64 thisPc,
gtUInt64 nextPc
)
{
jint* bcisArray = (jint*) vbcisArray;
jmethodID* methodArray = (jmethodID*) vmethodArray;
int xx;
numFrames -= 2;
for (xx = numFrames; xx >= 0; xx--)
{
LineNumSrc lns;
addrRanges addrRange;
bool ret = _getSrcInfoFromBcAndMethodID(bcisArray[xx],
methodArray[xx],
lns.lineNum,
lns.sourceFile);
if (false == ret)
{
continue;
}
addrRange.startAddr = thisPc;
addrRange.stopAddr = nextPc;
// lns.startAddr = thisPc;
// lns.stopAddr = nextPc;
lns.methodId = methodArray[xx];
lns.symName = GetMethodName(methodArray[xx]);
if ((gtUInt64) - 1 == nextPc)
{
for (unsigned int j = 1; j < m_addressRangeTable.size(); j++)
{
if ((m_addressRangeTable[j].id == methodArray[xx])
&& (thisPc >= (gtUInt64) m_addressRangeTable[j].pc_start)
&& (thisPc <= (gtUInt64) m_addressRangeTable[j].pc_end))
{
addrRange.startAddr = (gtUInt64) m_addressRangeTable[j].pc_start;
addrRange.stopAddr = (gtUInt64) m_addressRangeTable[j].pc_end;
break;
}
}
}
lns.addrs.push_back(addrRange);
ilmap.insert(JNCInlineMap::value_type(thisPc, lns));
}
}
ECode Int32PropertyValuesHolder::SetupSetter(
/* [in] */ IInterface* target)
{
if (mProperty != NULL) {
return NOERROR;
}
// Check new static hashmap<propName, int> for setter method
{
AutoLock lock(mPropertyMapLock);
AutoPtr<IClassInfo> clInfo = TransformClassInfo(target);
ClassMethodMapIterator exit = sJNISetterPropertyMap.Find(clInfo);
AutoPtr<MethodMap> propertyMap = NULL;
if(exit != sJNISetterPropertyMap.End())
{
propertyMap = exit->mSecond;
if(propertyMap != NULL)
{
MethodMapIterator it = propertyMap->Find(mPropertyName);
if(it != propertyMap->End())
{
AutoPtr<IMethodInfo> mtInfo = it->mSecond;
if(mtInfo != NULL)
{
mJniSetter = mtInfo;
}
}
}
}
if(mJniSetter == NULL)
{
String methodName = GetMethodName(String("Set"), mPropertyName);
clInfo->GetMethodInfo(methodName, (IMethodInfo**)&mJniSetter);
if(mJniSetter != NULL) {
if (propertyMap == NULL) {
propertyMap = new MethodMap();
sJNISetterPropertyMap[clInfo] = propertyMap;
}
(*propertyMap)[mPropertyName] = mJniSetter;
}
}
}
if (mJniSetter == NULL) {
// Couldn't find method through fast JNI approach - just use reflection
return PropertyValuesHolder::SetupSetter(target);
}
return NOERROR;
}
ECode MultiFloatValuesHolder::SetupSetter(
/* [in] */ IInterface* targetClass)
{
if (mJniSetter != NULL) {
return NOERROR;
}
// try {
AutoLock lock(mPropertyMapLock);
// mPropertyMapLock.writeLock().lock();
AutoPtr<IClassInfo> info = TransformClassInfo(targetClass);
AutoPtr<MethodMap> propertyMap = sJNISetterPropertyMap[info];
typename ClassMethodMap::Iterator it = sJNISetterPropertyMap.Find(info);
if ((it != sJNISetterPropertyMap.End()) && (it->mSecond != NULL)) {
propertyMap = it->mSecond;
typename MethodMap::Iterator it2 = propertyMap->Find(mPropertyName);
if ((it2 != propertyMap->End()) && (it2->mSecond != NULL)) {
mJniSetter = it2->mSecond;
}
}
if (mJniSetter == NULL) {
String methodName = GetMethodName(String("Set"), mPropertyName);
CalculateValue(0.f);
AutoPtr<IArrayList> values;
GetAnimatedValue((IInterface**)&values);
Int32 numParams = 0;
values->GetSize(&numParams);
try {
mJniSetter = nGetMultipleFloatMethod(info, methodName, numParams);
} catch (NoSuchMethodError e) {
// try without the 'set' prefix
mJniSetter = nGetMultipleFloatMethod(info, mPropertyName, numParams);
}
if (mJniSetter != NULL) {
if (propertyMap == NULL) {
propertyMap = new MethodMap();
sJNISetterPropertyMap[info] = propertyMap;
}
(*propertyMap)[mPropertyName] = mJniSetter;
}
}
// } finally {
// mPropertyMapLock.writeLock().unlock();
// }
return NOERROR;
}
ECode Int32PropertyValuesHolder::SetupSetter(
/* [in] */ IClassInfo* target)
{
if (mProperty != NULL) {
return NOERROR;
}
// Check new static hashmap<propName, int> for setter method
{
AutoLock lock(mPropertyMapLock);
String methodName = GetMethodName(String("Set"), mPropertyName);
AutoPtr<MethodMap> propertyMap;
ClassMethodMapIterator it = sNativeGetterSetterPropertyMap.Find(target);
if (it != sNativeGetterSetterPropertyMap.End()) {
propertyMap = it->mSecond;
}
if (propertyMap != NULL) {
MethodMapIterator mit = propertyMap->Find(methodName);
AutoPtr<IMethodInfo> mtInfo;
if (mit != propertyMap->End()) {
mtInfo = mit->mSecond;
}
if (mtInfo != NULL) {
mNativeSetter = mit->mSecond;
}
}
if (mNativeSetter == NULL) {
mNativeSetter = nGetInt32Method(target, methodName);
if (mNativeSetter != NULL) {
if (propertyMap == NULL) {
propertyMap = new MethodMap();
sNativeGetterSetterPropertyMap[target] = propertyMap;
}
(*propertyMap)[methodName] = mNativeSetter;
}
else {
String className;
target->GetName(&className);
Logger::E("Int32PropertyValuesHolder", "Error: Method [%s] is not found on target class %s",
methodName.string(), className.string());
}
}
}
return NOERROR;
}
/// <summary>Handle <c>ICorProfilerCallback::JITCompilationStarted</c></summary>
/// <remarks>The 'workhorse' </remarks>
HRESULT STDMETHODCALLTYPE CCodeInjection::JITCompilationStarted(
/* [in] */ FunctionID functionId, /* [in] */ BOOL fIsSafeToBlock)
{
ModuleID moduleId; mdToken funcToken;
std::wstring methodName = GetMethodName(functionId,
moduleId, funcToken);
ATLTRACE(_T("::JITCompilationStarted(%X -> %s)"),
functionId, W2CT(methodName.c_str()));
if (L"ProfilerTarget.Program.TargetMethod" == methodName &&
m_targetMethodRef !=0 ) {
// get method body
LPCBYTE pMethodHeader = NULL;
ULONG iMethodSize = 0;
COM_FAIL_RETURN(m_profilerInfo3->GetILFunctionBody(
moduleId, funcToken, &pMethodHeader, &iMethodSize),
S_OK);
// parse IL
Method instMethod((IMAGE_COR_ILMETHOD*)pMethodHeader); // <--
// insert new IL block
InstructionList instructions;
instructions.push_back(new Instruction(CEE_LDARG_0));
instructions.push_back(new Instruction(CEE_CALL, m_targetMethodRef));
instMethod.InsertSequenceInstructionsAtOriginalOffset(
1, instructions);
instMethod.DumpIL();
// allocate memory
CComPtr<IMethodMalloc> methodMalloc;
COM_FAIL_RETURN(m_profilerInfo3->GetILFunctionBodyAllocator(
moduleId, &methodMalloc), S_OK);
void* pNewMethod = methodMalloc->Alloc(instMethod.GetMethodSize());
// write new method
instMethod.WriteMethod((IMAGE_COR_ILMETHOD*)pNewMethod);
COM_FAIL_RETURN(m_profilerInfo3->SetILFunctionBody(moduleId,
funcToken, (LPCBYTE) pNewMethod), S_OK);
}
return S_OK;
}
ECode Int32PropertyValuesHolder::SetupGetter(
/* [in] */ IClassInfo* target)
{
if (mProperty != NULL) {
return NOERROR;
}
// Check new static hashmap<propName, int> for setter method
{
AutoLock lock(mPropertyMapLock);
String methodName = GetMethodName(String("Get"), mPropertyName);
AutoPtr<MethodMap> propertyMap;
ClassMethodMapIterator it = sNativeGetterSetterPropertyMap.Find(target);
if (it != sNativeGetterSetterPropertyMap.End()) {
propertyMap = it->mSecond;
}
if (propertyMap != NULL) {
MethodMapIterator mit = propertyMap->Find(methodName);
AutoPtr<IMethodInfo> mtInfo;
if (mit != propertyMap->End()) {
mtInfo = mit->mSecond;
}
if (mtInfo != NULL) {
mGetter = mit->mSecond;
}
}
if (mGetter == NULL) {
target->GetMethodInfo(methodName, String("(I32*)E"), (IMethodInfo**)&mGetter);
if (mGetter != NULL) {
if (propertyMap == NULL) {
propertyMap = new MethodMap();
sNativeGetterSetterPropertyMap[target] = propertyMap;
}
(*propertyMap)[methodName] = mGetter;
}
}
}
return NOERROR;
}
void
JavaJncReader::DumpAddressRangeTable(FILE* f)
{
(void)(f); // unused
#if 0
fprintf(f, "DumpAddressRangeTable - (size:%u)\n",
m_addressRangeTable.size());
for (unsigned int i = 0; i < m_addressRangeTable.size(); i++)
{
fprintf(f, "id:%4lu, pc_start:0x%lx, pc_end:0x%lx, name:%s\n",
m_addressRangeTable[i].id,
m_addressRangeTable[i].pc_start,
m_addressRangeTable[i].pc_end,
GetMethodName((jmethodID)m_addressRangeTable[i].id));
}
fprintf(f, "DumpAddressRangeTable: END\n");
#endif //0
return;
}
void
JavaJncReader::DumpAddressRangeTable(FILE* f)
{
if (nullptr == f)
{
return;
}
fprintf(f, "DumpAddressRangeTable - (size:%u)\n",
m_addressRangeTable.size());
for (unsigned int i = 0; i < m_addressRangeTable.size(); i++)
{
fprintf(f, "id:%4llu, pc_start:0x%llx, pc_end:0x%llx, name:%s\n",
m_addressRangeTable[i].id,
m_addressRangeTable[i].pc_start,
m_addressRangeTable[i].pc_end,
GetMethodName(m_addressRangeTable[i].id));
}
fprintf(f, "DumpAddressRangeTable: END\n");
return;
}
int JsonRpcCoder::EncodeResult(const Result& res, Json::Value& obj) const
{
Json::Value msgObj;
if(0 != res.JsonEncode(msgObj))
{
LOG_ERROR("serialNo:[%d], jsonencode error, res:[%s]", res.serialNo, res.ToString().c_str());
return -1;
}
obj["id"] = ToJsonValue(Json::Int(res.context.peer.msgId));
obj["errno"] = ToJsonValue(Json::Int(res.error));
if (res.errMsg.size()>0)
{
obj["errmsg"] = ToJsonValue(res.errMsg);
}
if( msgObj.type() != Json::nullValue)
{
obj["result"] = msgObj;
}
std::string msgName = res.GetTypeName();
const std::string& method = GetMethodName(msgName);
obj["method"] = ToJsonValue(method);
return 0;
}
VectorMap<String, String> Ide::GetMethodVars(const String& method)
{
VectorMap<String, String> map;
LoadVarFile(GetMethodName(method), map);
return map;
}
std::string Request::method_name() const { return GetMethodName(method()); }
/// <summary>Handle <c>ICorProfilerCallback::JITCompilationStarted</c></summary>
/// <remarks>The 'workhorse' </remarks>
HRESULT STDMETHODCALLTYPE CCodeInjection::JITCompilationStarted(
/* [in] */ FunctionID functionId, /* [in] */ BOOL fIsSafeToBlock)
{
ModuleID moduleId; mdToken funcToken;
std::wstring methodName = GetMethodName(functionId,
moduleId, funcToken);
ATLTRACE(_T("::JITCompilationStarted(%X -> %s)"),
functionId, W2CT(methodName.c_str()));
if (L"ProfilerTarget.Program.OnMethodToInstrument" == methodName &&
m_targetMethodRef !=0 ) {
// get method body
LPCBYTE pMethodHeader = NULL;
ULONG iMethodSize = 0;
COM_FAIL_RETURN(m_profilerInfo3->GetILFunctionBody(
moduleId, funcToken, &pMethodHeader, &iMethodSize),
S_OK);
CComPtr<IMetaDataEmit> metaDataEmit;
COM_FAIL_RETURN(m_profilerInfo3->GetModuleMetaData(moduleId,
ofRead | ofWrite, IID_IMetaDataEmit, (IUnknown**)&metaDataEmit), S_OK);
// parse IL
Method instMethod((IMAGE_COR_ILMETHOD*)pMethodHeader); // <--
instMethod.SetMinimumStackSize(3); // should be correct for this sample
// NOTE: build signature (in the knowledge that the method we are instrumenting currently has no local vars)
static COR_SIGNATURE localSignature[] =
{
IMAGE_CEE_CS_CALLCONV_LOCAL_SIG,
0x02,
ELEMENT_TYPE_ARRAY, ELEMENT_TYPE_OBJECT, 01, 00, 00,
ELEMENT_TYPE_ARRAY, ELEMENT_TYPE_OBJECT, 01, 00, 00
};
mdSignature signature;
COM_FAIL_RETURN(metaDataEmit->GetTokenFromSig(localSignature, sizeof(localSignature), &signature), S_OK);
instMethod.m_header.LocalVarSigTok = signature;
// insert new IL block
InstructionList instructions; // NOTE: this IL will be different for an instance method or if the local vars signature is different
instructions.push_back(new Instruction(CEE_NOP));
instructions.push_back(new Instruction(CEE_LDC_I4_2));
instructions.push_back(new Instruction(CEE_NEWARR, m_objectTypeRef));
instructions.push_back(new Instruction(CEE_STLOC_1));
instructions.push_back(new Instruction(CEE_LDLOC_1));
instructions.push_back(new Instruction(CEE_LDC_I4_0));
instructions.push_back(new Instruction(CEE_LDARG_0));
instructions.push_back(new Instruction(CEE_STELEM_REF));
instructions.push_back(new Instruction(CEE_LDLOC_1));
instructions.push_back(new Instruction(CEE_LDC_I4_1));
instructions.push_back(new Instruction(CEE_LDARG_1));
instructions.push_back(new Instruction(CEE_STELEM_REF));
instructions.push_back(new Instruction(CEE_LDLOC_1));
instructions.push_back(new Instruction(CEE_STLOC_0));
instructions.push_back(new Instruction(CEE_LDLOC_0));
instructions.push_back(new Instruction(CEE_CALL, m_targetMethodRef));
instMethod.InsertSequenceInstructionsAtOriginalOffset(
0, instructions);
instMethod.DumpIL();
// allocate memory
CComPtr<IMethodMalloc> methodMalloc;
COM_FAIL_RETURN(m_profilerInfo3->GetILFunctionBodyAllocator(
moduleId, &methodMalloc), S_OK);
void* pNewMethod = methodMalloc->Alloc(instMethod.GetMethodSize());
// write new method
instMethod.WriteMethod((IMAGE_COR_ILMETHOD*)pNewMethod);
COM_FAIL_RETURN(m_profilerInfo3->SetILFunctionBody(moduleId,
funcToken, (LPCBYTE) pNewMethod), S_OK);
// update IL maps
ULONG mapSize = instMethod.GetILMapSize();
void* pMap = CoTaskMemAlloc(mapSize * sizeof(COR_IL_MAP));
instMethod.PopulateILMap(mapSize, (COR_IL_MAP*)pMap);
COM_FAIL_RETURN(m_profilerInfo3->SetILInstrumentedCodeMap(
functionId, TRUE, mapSize, (COR_IL_MAP*)pMap), S_OK);
CoTaskMemFree(pMap);
}
return S_OK;
}
void AdminCache::DumpCache(FILE *fp)
{
int *itable;
AdminId aid;
GroupId gid;
char flagstr[64];
unsigned int num;
AdminUser *pAdmin;
AdminGroup *pGroup;
char name_buffer[512];
fprintf(fp, "\"Groups\"\n{\n");
num = 0;
gid = m_FirstGroup;
while (gid != INVALID_GROUP_ID
&& (pGroup = GetGroup(gid)) != NULL)
{
num++;
FillFlagString(pGroup->addflags, flagstr, sizeof(flagstr));
fprintf(fp, "\t/* num = %d, gid = 0x%X */\n", num, gid);
fprintf(fp, "\t\"%s\"\n\t{\n", GetString(pGroup->nameidx));
fprintf(fp, "\t\t\"flags\"\t\t\t\"%s\"\n", flagstr);
fprintf(fp, "\t\t\"immunity\"\t\t\"%d\"\n", pGroup->immunity_level);
if (pGroup->immune_table != -1
&& (itable = (int *)m_pMemory->GetAddress(pGroup->immune_table)) != NULL)
{
AdminGroup *pAltGroup;
const char *gname, *mod;
for (int i = 1; i <= itable[0]; i++)
{
if ((pAltGroup = GetGroup(itable[i])) == NULL)
{
/* Assume the rest of the table is corrupt */
break;
}
gname = GetString(pAltGroup->nameidx);
if (atoi(gname) != 0)
{
mod = "@";
}
else
{
mod = "";
}
fprintf(fp, "\t\t\"immunity\"\t\t\"%s%s\"\n", mod, gname);
}
}
fprintf(fp, "\n\t\t\"Overrides\"\n\t\t{\n");
if (pGroup->pCmdGrpTable != NULL)
{
sm_trie_bad_iterator(pGroup->pCmdGrpTable,
name_buffer,
sizeof(name_buffer),
iterator_group_grp_override,
fp);
}
if (pGroup->pCmdTable != NULL)
{
sm_trie_bad_iterator(pGroup->pCmdTable,
name_buffer,
sizeof(name_buffer),
iterator_group_basic_override,
fp);
}
fprintf(fp, "\t\t}\n");
fprintf(fp, "\t}\n");
if ((gid = pGroup->next_grp) != INVALID_GROUP_ID)
{
fprintf(fp, "\n");
}
}
fprintf(fp, "}\n\n");
fprintf(fp, "\"Admins\"\n{\n");
num = 0;
aid = m_FirstUser;
while (aid != INVALID_ADMIN_ID
&& (pAdmin = GetUser(aid)) != NULL)
{
num++;
FillFlagString(pAdmin->flags, flagstr, sizeof(flagstr));
fprintf(fp, "\t/* num = %d, aid = 0x%X, serialno = 0x%X*/\n", num, aid, pAdmin->serialchange);
if (pAdmin->nameidx != -1)
{
fprintf(fp, "\t\"%s\"\n\t{\n", GetString(pAdmin->nameidx));
}
else
{
fprintf(fp, "\t\"\"\n\t{\n");
}
if (pAdmin->auth.identidx != -1)
{
fprintf(fp, "\t\t\"auth\"\t\t\t\"%s\"\n", GetMethodName(pAdmin->auth.index));
fprintf(fp, "\t\t\"identity\"\t\t\"%s\"\n", GetString(pAdmin->auth.identidx));
}
if (pAdmin->password != -1)
{
fprintf(fp, "\t\t\"password\"\t\t\"%s\"\n", GetString(pAdmin->password));
}
fprintf(fp, "\t\t\"flags\"\t\t\t\"%s\"\n", flagstr);
fprintf(fp, "\t\t\"immunity\"\t\t\"%d\"\n", pAdmin->immunity_level);
if (pAdmin->grp_count != 0
&& pAdmin->grp_table != -1
&& (itable = (int *)m_pMemory->GetAddress(pAdmin->grp_table)) != NULL)
{
unsigned int i;
for (i = 0; i < pAdmin->grp_count; i++)
{
if ((pGroup = GetGroup(itable[i])) == NULL)
{
/* Assume the rest of the table is corrupt */
break;
}
fprintf(fp, "\t\t\"group\"\t\t\t\"%s\"\n", GetString(pGroup->nameidx));
}
}
fprintf(fp, "\t}\n");
if ((aid = pAdmin->next_user) != INVALID_ADMIN_ID)
{
fprintf(fp, "\n");
}
}
fprintf(fp, "}\n\n");
fprintf(fp, "\"Overrides\"\n{\n");
if (m_pCmdGrpOverrides != NULL)
{
sm_trie_bad_iterator(m_pCmdGrpOverrides,
name_buffer,
sizeof(name_buffer),
iterator_glob_grp_override,
fp);
}
if (m_pCmdOverrides != NULL)
{
sm_trie_bad_iterator(m_pCmdOverrides,
name_buffer,
sizeof(name_buffer),
iterator_glob_basic_override,
fp);
}
fprintf(fp, "}\n");
}
void CPipeServer::Start(void)
{
BYTE command;
while (TRUE)
{
CreatePipeandWaitForconnect();
try
{
while (TRUE)
{
command=ReadByte();
switch(command)
{
case MONOCMD_INITMONO:
InitMono();
break;
case MONOCMD_OBJECT_GETCLASS:
Object_GetClass();
break;
case MONOCMD_ENUMDOMAINS:
EnumDomains();
break;
case MONOCMD_SETCURRENTDOMAIN:
SetCurrentDomain();
break;
case MONOCMD_ENUMASSEMBLIES:
EnumAssemblies();
break;
case MONOCMD_GETIMAGEFROMASSEMBLY:
GetImageFromAssembly();
break;
case MONOCMD_GETIMAGENAME:
GetImageName();
break;
case MONOCMD_ENUMCLASSESINIMAGE:
EnumClassesInImage();
break;
case MONOCMD_ENUMFIELDSINCLASS:
EnumFieldsInClass();
break;
case MONOCMD_ENUMMETHODSINCLASS:
EnumMethodsInClass();
break;
case MONOCMD_COMPILEMETHOD:
CompileMethod();
break;
case MONOCMD_GETMETHODHEADER:
GetMethodHeader();
break;
case MONOCMD_GETMETHODHEADER_CODE:
GetILCode();
break;
case MONOCMD_LOOKUPRVA:
RvaMap();
break;
case MONOCMD_GETJITINFO:
GetJitInfo();
break;
case MONOCMD_FINDCLASS:
FindClass();
break;
case MONOCMD_FINDMETHOD:
FindMethod();
break;
case MONOCMD_GETMETHODNAME:
GetMethodName();
break;
case MONOCMD_GETMETHODCLASS:
GetMethodClass();
break;
case MONOCMD_GETCLASSNAME:
GetKlassName();
break;
case MONOCMD_GETCLASSNAMESPACE:
GetClassNamespace();
break;
case MONOCMD_FREEMETHOD:
FreeMethod();
break;
case MONOCMD_TERMINATE:
return;
case MONOCMD_DISASSEMBLE:
DisassembleMethod();
break;
case MONOCMD_GETMETHODSIGNATURE:
GetMethodSignature();
break;
case MONOCMD_GETPARENTCLASS:
GetParentClass();
break;
case MONOCMD_GETSTATICFIELDADDRESSFROMCLASS:
GetStaticFieldAddressFromClass();
break;
}
}
}
catch (char *e)
{
//Pipe error, or something else that wasn't caught. Exit the connection and start over
OutputDebugStringA("Pipe error:\n");
OutputDebugStringA(e);
if (attached)
{
mono_thread_detach(mono_selfthread);
attached=FALSE;
}
}
catch (...)
{
OutputDebugStringA("Unexpected pipe error\n");
if (attached)
{
mono_thread_detach(mono_selfthread);
attached=FALSE;
}
}
}
}
