void DoDel(CommandSource &source, ChannelInfo *ci, const Anope::string &message)
{
EntryMessageList *messages = ci->GetExt<EntryMessageList *>("cs_entrymsg");
if (!message.is_pos_number_only())
source.Reply(("Entry message \002%s\002 not found on channel \002%s\002."), message.c_str(), ci->name.c_str());
else if (messages != NULL)
{
try
{
unsigned i = convertTo<unsigned>(message);
if (i > 0 && i <= messages->size())
{
messages->erase(messages->begin() + i - 1);
if (messages->empty())
ci->Shrink("cs_entrymsg");
source.Reply(_("Entry message \002%i\002 for \002%s\002 deleted."), i, ci->name.c_str());
}
else
throw ConvertException();
}
catch (const ConvertException &)
{
source.Reply(_("Entry message \002%s\002 not found on channel \002%s\002."), message.c_str(), ci->name.c_str());
}
}
else
source.Reply(_("Entry message list for \002%s\002 is empty."), ci->name.c_str());
}
void Parser::setBuffer(string arqName, vector<vector<vector<uint8_t>>> value,
int nbSamplesIn, int sampleFormatIn, int sampleRateIn,
uint64_t channelLayoutIn, int nbChannelsIn)
{
int error;
this->fileName = arqName;
this->bufFrames = value;
this->nbSamplesIn = nbSamplesIn;
this->sampleFormatIn = sampleFormatIn;
this->sampleRateIn = sampleRateIn;
this->channelLayoutIn = channelLayoutIn;
this->nbChannelsIn = nbChannelsIn;
if (swr_ctx)
swr_free(&swr_ctx);
InitResampler();
if (audioFormat == AUDIOFORMAT::arq)
{
AVIOContext **io_ctx = &fmt_ctx_out->pb;
if (*io_ctx)
avio_close(*io_ctx);
error = avio_open(io_ctx, fileName.c_str(), AVIO_FLAG_WRITE);
if (error < 0)
{
char error_buffer[255];
av_strerror(error, error_buffer, sizeof(error_buffer));
objLog->mr_printf(MR_LOG_ERROR, idRadio, "Error: %s - %s\n", fileName.c_str(), error_buffer);
throw ConvertException() << errno_code(MIR_ERR_OPEN_OUTPUT_FILE);
}
av_dump_format(fmt_ctx_out, 0, fileName.c_str(), 1);
error = avformat_write_header(fmt_ctx_out, NULL);
if (error < 0)
{
char error_buffer[255];
av_strerror(error, error_buffer, sizeof(error_buffer));
objLog->mr_printf(MR_LOG_ERROR, idRadio, "Error: %s - %s\n", fileName.c_str(), error_buffer);
throw StreamException() << errno_code(MIR_ERR_OPEN_STREAM_3);
}
}
}
/*----------------------------------------------------------------------------------------------
This function can be installed to translate windows exceptions into C++ internal error
exceptions. Only the main program should do this. To install, just call
_set_se_translator(TransFuncDump);.
This is of dubious value because if the error occurs inside a COM component, the Throwable
exception will not be recognized, and exception handling will just catch "..." and generate
a new stack dump. However, installing it at least achieves better stack dumps for errors
in code linked into the main program.
We could install at the start of every COM interface method, and restore upon return.
However this would be computationally expensive. Consider doing this in a particular method
if you are trying to track down a problem in that method.
We could have each module install this function on being loaded, and check whether the
error occurs in its own code, and if not call the previous error handler. But this
only works reliably if modules are never unloaded, or only in reverse order of loading,
which I don't see how to ensure.
We could also get really fancy, with some sort of central manager which knows which error
translator to use for each module. This has not seemed worthwhile to me so far.
----------------------------------------------------------------------------------------------*/
void TransFuncDump( unsigned int u, EXCEPTION_POINTERS * pExp)
{
#ifdef WIN32
HANDLE hThread;
DWORD dwCode = pExp->ExceptionRecord->ExceptionCode;
StrUni stuException = ConvertException(dwCode);
DuplicateHandle( GetCurrentProcess(), GetCurrentThread(),
GetCurrentProcess(), &hThread, 0, false, DUPLICATE_SAME_ACCESS );
StrAnsi staMsg;
staMsg.Format("Stack Dump for exception: %S (%d)", stuException.Chars(), dwCode);
StackDumper::ShowStack( hThread, *(pExp->ContextRecord), const_cast<char *>(staMsg.Chars()) );
CloseHandle( hThread );
StrUni stuMsg(staMsg.Chars());
throw ThrowableSd(E_UNEXPECTED, stuMsg.Chars(), 0, StackDumper::GetDump());
#endif
}
/*----------------------------------------------------------------------------------------------
// This method is called when a Throwable exception is caught at the end of a COM method,
// or (with a dummy ThrowableSd) when some other exception is caught. It transforms the info
// in the Throwable into a standard COM error report (creating an IErrorInfo and registering
// it.) It returns the HRESULT that should be returned by the COM method.
// There are several different situations which this method has to handle. The following
// comments describe the situations, and how they are indicated. Each "indication" presumes
// that the previous "indications" failed.
// 1. We called a COM method which supports IErrorInfo and already provides all the information
// we need to pass to our own caller. This is indicated by a help ID of -1.
// 2. We, or a method we called that doesn't support IErrorInfo, ran out of memory.
// We need to set up the special error object pre-created for this case. This is
// indicated by thr.Error() being E_OUTOFMEMORY.
// 3. A programming error has been caught and a stack dump generated, either in our own code
// or in the code that called us. This is indicated by finding that thr is actually
// a ThrowableSd. Make an error object, with a description that includes the stack dump.
----------------------------------------------------------------------------------------------*/
HRESULT HandleThrowable(Throwable & thr, REFGUID iid, DummyFactory * pfact)
{
StrUni stuDesc;
HRESULT hrErr = thr.Error();
HRESULT hr;
// If we already have error info, we set it again (very likely got cleared by previous
// CheckHr), and then just return the HRESULT.
if (thr.GetErrorInfo())
{
::SetErrorInfo(0, thr.GetErrorInfo());
return hrErr;
}
// We need a Unicode version of the ProgId, but we should avoid allocating memory
// since we don't yet know that we have not run out.
// Since all our progids are in simple ascii, we can do the simplest possible conversion.
// Since we hopefully have at least a little stack to work with, use _alloca.
OLECHAR * pszSrc = (OLECHAR *)_alloca((StrLen(pfact->GetProgId()) + 1) * isizeof(OLECHAR));
OLECHAR * pchw = pszSrc;
for (const TCHAR * pch = pfact->GetProgId(); *pch; pch++, pchw++)
*pchw = *pch;
*pchw = 0;
if (hrErr == E_OUTOFMEMORY)
{
// Use the pre-created error info object so we don't have to allocate now.
// It already has a description, help file path, and help context ID.
// If a further E_OUTOFMEMORY occurs calling SetGUID or SetSource, just ignore it.
s_qcerrinfoMem->SetGUID(iid);
s_qcerrinfoMem->SetSource(pszSrc);
SetErrorInfo(0, s_qerrinfoMem);
return hrErr;
}
// Otherwise we are going to make a new error info object.
// Get any message supplied by the Throwable.
StrUni stuUserMsg(thr.Message());
// See if a stack dump is available.
ThrowableSd * pthrs = dynamic_cast<ThrowableSd *>(&thr);
char * pchDump = NULL;
if (pthrs)
pchDump = const_cast<char *>(pthrs->GetDump());
else if (!stuUserMsg.Length())
{
// If we don't have any sort of nice message, treat it as an internal error.
DumpStackHere("HandleThrowable caught an error with no description");
pchDump = const_cast<char *>(StackDumper::GetDump());
}
if (pchDump)
{
// We have a stack dump.
StrUni stuModName = ModuleEntry::GetModulePathName();
// Do we already have a description? If not make one.
if (!stuUserMsg.Length())
{
// No, use a default one.
StrUni stuHrMsg = ConvertException((DWORD)hrErr);
StrUni stuUserMsgFmt;
stuUserMsgFmt.Load(kstidInternalError);
// Would it be better to strip off the path?
stuUserMsg.Format(stuUserMsgFmt, stuHrMsg.Chars(), stuModName.Chars());
}
stuDesc.Format(L"%s%s%S\r\n\r\n%s", stuUserMsg.Chars(), ThrowableSd::MoreSep(), pchDump,
GetModuleVersion(stuModName.Chars()).Chars());
}
else
{
// We've made sure we have a message already; use it.
stuDesc = stuUserMsg;
}
StrUni stuSource(pszSrc);
hr = StackDumper::RecordError(iid, stuDesc, stuSource, thr.HelpId(),
GetModuleHelpFilePath());
if (FAILED(hr))
{
if (hr == E_OUTOFMEMORY)
{
Throwable thr2(E_OUTOFMEMORY);
return HandleThrowable(thr2, iid, pfact);
}
// just report the failure to the developer
WarnHr(hr);
// Hard to know what do do here. It should never happen. For paranoia's sake at least
// return the original problem.
}
return hrErr;
}
void ThrowHrEx(HRESULT hr, int hHelpId)
{
StrUni msg = ConvertException(::GetLastError());
ThrowHr(hr, msg.Chars(), hHelpId);
}
