int main() { int levelNum, pathNum; getPathAndLevelNumbers(&levelNum, &pathNum); char *filePath = makeFilePath(levelNum, pathNum); checkForDuplicateFile(filePath); initSDL(); Display d = (Display)malloc(sizeof(struct display)); openMapInSDLWindow(d); FILE *tmpFP = createTempFile(); int numberOfCoords = recordStepsInTempFile(tmpFP, d); writeCoordsToFile(numberOfCoords, tmpFP, filePath); return 0; }
// return "" or "-CMFN=modNamList_" where modNamList_ is a temp file that // has the list of module names to be extracted by MDFWriter. // requires: cmfn is long enough to hold "-CMFN=modNamList_". char* SQLJFile::getModuleNamesOption(Cmdline_Args &args, char *cmfn) { ExtQualModuleNames* EQMNs = args.getModuleNames(); Int32 count; if (!EQMNs || (count=EQMNs->count()) <= 0) { return ""; // means extract all } else { // create a temporary file char *modNamFil, modNam[L_tmpnam+20], templNam[L_tmpnam+26]; modNamFil = getTempFileName(modNam); if (!modNamFil) { return NULL; } FILE *tFil = createTempFile(modNamFil, templNam); if (!tFil) { return NULL; } // write into temp file the names of modules to be extracted for (Int32 x=0; x<count; x++) { const ThreePartModuleName& modNam = EQMNs->at(x); fprintf(tFil, "%s\n", modNam.catalog.c_str()); fprintf(tFil, "%s\n", modNam.schema.c_str()); fprintf(tFil, "%s\n", modNam.module.c_str()); } fclose(tFil); // return "-CMFN=modNamList_" strcpy(cmfn, "-CMFN="); strcat(cmfn, templNam); strcat(cmfn, " "); modNamList_ = templNam; return cmfn; } }
/** \brief Creates temporary file containing sensitive DB info. * * So we don't have to specify the password on the command line, use * --defaults-extra-file to specify a temporary file with a [client] and * [mysqldump] section that provides the password. This will fail if the * user's ~/.my.cnf (which is read after the --defaults-extra-file) * specifies a different password that's incorrect for dbUserName */ bool DBUtil::CreateTemporaryDBConf( const QString &privateinfo, QString &filename) { bool ok = true; filename = createTempFile("/tmp/mythtv_db_backup_conf_XXXXXX"); const QByteArray tmpfile = filename.toLocal8Bit(); const DatabaseParams dbParams = gCoreContext->GetDatabaseParams(); const QString dbSchemaVer = gCoreContext->GetSetting("DBSchemaVer"); FILE *fp = fopen(tmpfile.constData(), "w"); if (!fp) { LOG(VB_GENERAL, LOG_ERR, LOC + QString("Unable to create temporary " "configuration file for creating DB backup: %1") .arg(tmpfile.constData())); filename = ""; ok = false; } else { chmod(tmpfile.constData(), S_IRUSR); QByteArray outarr = privateinfo.toLocal8Bit(); fprintf(fp, "%s", outarr.constData()); if (fclose(fp)) { LOG(VB_GENERAL, LOG_ERR, LOC + QString("Error closing '%1'") .arg(tmpfile.constData()) + ENO); } } return ok; }
TemporaryFile::TemporaryFile (const File& target, const int optionFlags) : temporaryFile (createTempFile (target.getParentDirectory(), target.getFileNameWithoutExtension() + "_temp" + String::toHexString (Random::getSystemRandom().nextInt()), target.getFileExtension(), optionFlags)), targetFile (target) { // If you use this constructor, you need to give it a valid target file! jassert (targetFile != File()); }
TITANIUM_FUNCTION(FilesystemModule, createTempFile) { const auto js_context = this_object.get_context(); const auto filesystem_ptr = GetStaticObject(js_context).GetPrivate<FilesystemModule>(); const auto object_ptr = filesystem_ptr->createTempFile(this_object.get_context()); if (object_ptr != nullptr) { return object_ptr->get_object(); } return this_object.get_context().CreateUndefined(); }
void CppToolsPlugin::test_headersource() { QFETCH(QString, sourceFileName); QFETCH(QString, headerFileName); Tests::TemporaryDir temporaryDir; QVERIFY(temporaryDir.isValid()); const QDir path = QDir(temporaryDir.path() + QLatin1Char('/') + _(QTest::currentDataTag())); const QString sourcePath = path.absoluteFilePath(sourceFileName); const QString headerPath = path.absoluteFilePath(headerFileName); createTempFile(sourcePath); createTempFile(headerPath); bool wasHeader; clearHeaderSourceCache(); QCOMPARE(correspondingHeaderOrSource(sourcePath, &wasHeader), headerPath); QVERIFY(!wasHeader); clearHeaderSourceCache(); QCOMPARE(correspondingHeaderOrSource(headerPath, &wasHeader), sourcePath); QVERIFY(wasHeader); }
SystemServices::SystemServices(int iLogLevel, int job_id, char* user_name) : m_iLogLevel(iLogLevel) { m_fp = NULL; if (iLogLevel & SAVE_PCL_FILE) { char fname[MAX_FILE_PATH_LEN]; sprintf(fname, "%s/hp_%s_cups_out_job%d_XXXXXX",CUPS_TMP_DIR, user_name, job_id); createTempFile(fname, &m_fp); if (m_fp) chmod(fname, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); } }
imeth char * BufferedTempFile_im_gName(object self) { BufferedTempFile_iv_t *iv = GetIVs(BufferedTempFile, self); if (iv->iTmpFile) return gName(iv->iTmpFile); else { createTempFile(self); return gName(self); } }
imeth void * BufferedTempFile_im_gPointerValue(object self) { BufferedTempFile_iv_t *iv = GetIVs(BufferedTempFile, self); if (iv->iTmpFile) return gPointerValue(iv->iTmpFile); else { createTempFile(self); return gPointerValue(self); } }
QgsRasterLayer* QgsSentDataSourceBuilder::rasterLayerFromSentRDS( const QDomElement& sentRDSElem, QList<QTemporaryFile*>& filesToRemove, QList<QgsMapLayer*>& layersToRemove ) const { QgsMSDebugMsg( "Entering" ); QString tempFilePath = createTempFile(); if ( tempFilePath.isEmpty() ) { return 0; } QFile tempFile( tempFilePath ); QTemporaryFile* tmpFile = new QTemporaryFile(); QString encoding = sentRDSElem.attribute( "encoding" ); if ( encoding == "base64" ) { if ( tmpFile->open() ) { QByteArray binaryContent = QByteArray::fromBase64( sentRDSElem.text().toAscii() ); QDataStream ds( tmpFile ); ds.writeRawData( binaryContent.data(), binaryContent.length() ); } else { delete tmpFile; return 0; } } else //assume text (e.g. ascii grid) { if ( tmpFile->open() ) { QTextStream tempFileStream( tmpFile ); tempFileStream << sentRDSElem.text(); } else { delete tmpFile; return 0; } } QgsMSDebugMsg( "TempFilePath is: " + tempFilePath ); tmpFile->close(); QgsRasterLayer* rl = new QgsRasterLayer( tmpFile->fileName(), layerNameFromUri( tmpFile->fileName() ) ); filesToRemove.push_back( tmpFile ); //make sure the temporary file gets deleted after each request layersToRemove.push_back( rl ); //make sure the layer gets deleted after each request return rl; }
TempOctree::TempOctree(char* fileNameTemplate,unsigned int sMaxNumPointsPerNode,LidarPoint* points,size_t numPoints) :tempFileName(new char[strlen(fileNameTemplate)+1]), file(createTempFile(fileNameTemplate),File::ReadWrite), maxNumPointsPerNode(sMaxNumPointsPerNode), pointBbox(Box::empty), writerThreadRun(true),writerThread(this,&TempOctree::writerThreadMethod) { /* Save the temporary file name: */ strcpy(tempFileName,fileNameTemplate); /* Immediately unlink the temporary file; it will stay alive until the file handle is closed: */ unlink(tempFileName); /* Calculate the point set's bounding box: */ for(unsigned int i=0;i<numPoints;++i) pointBbox.addPoint(points[i]); /* Extend the bounding box by a small delta to include all points in a half-open box: */ Point newMax=pointBbox.max; for(int i=0;i<3;++i) { Scalar delta=Scalar(1); if(newMax[i]+delta!=newMax[i]) { while(newMax[i]+(delta*Scalar(0.5))!=newMax[i]) delta*=Scalar(0.5); } else { while(newMax[i]+delta==newMax[i]) delta*=Scalar(2); } newMax[i]+=delta; } pointBbox=Box(pointBbox.min,newMax); /* Set the root's domain to contain all points: */ root.domain=Cube(pointBbox); /* Create the root node's subtree: */ root.numPoints=numPoints; root.points=points; createSubTree(root); /* Wait until the octree file is finished: */ writerThreadRun=false; writeQueueCond.signal(); writerThread.join(); file.flush(); }
void write(rfs_fpos_t pos, size_t len, const void *in) { if (!writeok) base.throwError(EACCES,"invalid mode for write"); if (tempfile==-1) tempfile = createTempFile(base,tempfilename); long ret = (long)_lseek(tempfile,(long)pos,SEEK_SET); if (ret!=pos) base.throwError(errno,"write.1"); int wr = _write(tempfile,in,len); if (wr==-1) base.throwError(errno,"write.2"); if (wr!=len) // disk full base.throwError(ENOSPC,"write.3"); if (pos+wr>savesize) savesize = pos+wr; }
void loadZipFile2(const char* ipsw, OutputState** output, const char* file, int useMemory) { char* fileName; void* buffer; unzFile zip; unz_file_info pfile_info; ASSERT(zip = unzOpen(ipsw), "cannot open input ipsw"); ASSERT(unzGoToFirstFile(zip) == UNZ_OK, "cannot seek to first file in input ipsw"); do { ASSERT(unzGetCurrentFileInfo(zip, &pfile_info, NULL, 0, NULL, 0, NULL, 0) == UNZ_OK, "cannot get current file info from ipsw"); fileName = (char*) malloc(pfile_info.size_filename + 1); ASSERT(unzGetCurrentFileInfo(zip, NULL, fileName, pfile_info.size_filename + 1, NULL, 0, NULL, 0) == UNZ_OK, "cannot get current file name from ipsw"); if((file == NULL && fileName[strlen(fileName) - 1] != '/') || (file != NULL && strcmp(fileName, file)) == 0) { printf("loading: %s (%ld)\n", fileName, pfile_info.uncompressed_size); fflush(stdout); ASSERT(unzOpenCurrentFile(zip) == UNZ_OK, "cannot open compressed file in IPSW"); if(useMemory) { buffer = malloc((pfile_info.uncompressed_size > 0) ? pfile_info.uncompressed_size : 1); ASSERT(unzReadCurrentFile(zip, buffer, pfile_info.uncompressed_size) == pfile_info.uncompressed_size, "cannot read file from ipsw"); addToOutput(output, fileName, buffer, pfile_info.uncompressed_size); } else { char* tmpFileName = createTempFile(); FILE* tmpFile = fopen(tmpFileName, "wb"); buffer = malloc(DEFAULT_BUFFER_SIZE); size_t left = pfile_info.uncompressed_size; while(left > 0) { size_t toRead; if(left > DEFAULT_BUFFER_SIZE) toRead = DEFAULT_BUFFER_SIZE; else toRead = left; ASSERT(unzReadCurrentFile(zip, buffer, toRead) == toRead, "cannot read file from ipsw"); fwrite(buffer, toRead, 1, tmpFile); left -= toRead; } fclose(tmpFile); free(buffer); addToOutput2(output, fileName, NULL, pfile_info.uncompressed_size, tmpFileName); } ASSERT(unzCloseCurrentFile(zip) == UNZ_OK, "cannot close compressed file in IPSW"); } free(fileName); } while(unzGoToNextFile(zip) == UNZ_OK); ASSERT(unzClose(zip) == UNZ_OK, "cannot close input ipsw file"); }
int main(int argc, char *argv[]) { if (argc < 2) { return error( "usage: [path] [extensions]\n" "\tOR [filename]\n" //"usage: [filenames]\n" //"\tOR [path] -ext [extensions]\n" "Available options are: \n" " -mode EOL mode (unix, dos, mac)\n" " -skiperrors skip any errors when processing files\n" " -nolog hide logs (can increase speed)" // TODO: //" -depth max directory depth (-1 by default)\n" //" -b make backups\n" //" -bext backup extension (\"bak\" by default)\n" //" -bdir backup directory\n" //" -perf output processing time\n" ); } if (processArgs(argc, argv)) return 1; if (!createTempFile()) return error("failed to create a temporary file"); int res = 0; if (SearchFiles) { res = searchRecursive(searchpath, extensions); } else { if (!processFile(searchpath)) res = error("unable to open file"); } deleteTempFile(); return res; }
/*! * Saves the settings to a file. The settings are first * saved to a temporary file, and then that file is copied * over the original settings. This avoids clearing settings * when there's no disk space. * \param originalSettings Settings to save. */ static bool doSync(QSettings &originalSettings, QScopedPointer<QFileSystemWatcher>& watcher) { bool returnValue = false; QString tempFileName = createTempFile(originalSettings.fileName()); if (!tempFileName.isEmpty()) { QSettings copiedSettings(tempFileName, QSettings::IniFormat); if (copySettings(originalSettings, copiedSettings)) { copiedSettings.sync(); if (copiedSettings.status() == QSettings::NoError) { renameSettingFile(tempFileName, originalSettings.fileName()); originalSettings.sync(); returnValue = true; } } } addPathsToWatcher(originalSettings.fileName(), watcher); return returnValue; }
imeth int BufferedTempFile_im_gWrite(object self, char *buf, unsigned n) { BufferedTempFile_iv_t *iv = GetIVs(BufferedTempFile, self); if (iv->iTmpFile) return gWrite(iv->iTmpFile, buf, n); else { if (n + iv->iCurrentOffset > iv->iBufSize) { createTempFile(self); return gWrite(self, buf, n); } else { memcpy(iv->iBuffer + iv->iCurrentOffset, buf, n); iv->iCurrentOffset += n; iv->iSize = max(iv->iCurrentOffset, iv->iSize); return n; } } }
void setLogLevel(UXServices *pSS, char*user_name) { FILE *fp; char str[258]; char *p; fp = fopen ("/etc/cups/cupsd.conf", "r"); if (fp == NULL) return; while (!feof (fp)) { if (!fgets (str, 256, fp)) { break; } if ((p = strstr (str, "hpLogLevel"))) { p += strlen ("hpLogLevel") + 1; pSS->m_iLogLevel = atoi (p); break; } } fclose (fp); if (pSS->m_iLogLevel & SAVE_PCL_FILE) { char szFileName[MAX_FILE_PATH_LEN]; snprintf (szFileName,sizeof(szFileName), "%s/hp_%s_ijs_%d_XXXXXX", CUPS_TMP_DIR, user_name, getpid()); createTempFile(szFileName, &pSS->outfp); // pSS->outfp = fopen (szFileName, "w"); if (pSS->outfp) { chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); } } }
int doPatch(StringValue* patchValue, StringValue* fileValue, const char* bundlePath, OutputState** state, unsigned int* key, unsigned int* iv, int useMemory, int isPlain) { char* patchPath; size_t bufferSize; void* buffer; AbstractFile* patchFile; AbstractFile* file; AbstractFile* out; AbstractFile* outRaw; char* tmpFileName; if(useMemory) { bufferSize = 0; buffer = malloc(1); outRaw = createAbstractFileFromMemoryFile((void**)&buffer, &bufferSize); } else { tmpFileName = createTempFile(); outRaw = createAbstractFileFromFile(fopen(tmpFileName, "wb")); } patchPath = malloc(sizeof(char) * (strlen(bundlePath) + strlen(patchValue->value) + 2)); strcpy(patchPath, bundlePath); strcat(patchPath, "/"); strcat(patchPath, patchValue->value); XLOG(0, "%s (%s)... ", fileValue->value, patchPath); fflush(stdout); patchFile = createAbstractFileFromFile(fopen(patchPath, "rb")); if (isPlain) { out = outRaw; file = getFileFromOutputState(state, fileValue->value); } else { if(key != NULL) { XLOG(0, "encrypted input... "); out = duplicateAbstractFile2(getFileFromOutputState(state, fileValue->value), outRaw, key, iv, NULL); } else { out = duplicateAbstractFile(getFileFromOutputState(state, fileValue->value), outRaw); } if(key != NULL) { XLOG(0, "encrypted output... "); file = openAbstractFile2(getFileFromOutputState(state, fileValue->value), key, iv); } else { file = openAbstractFile(getFileFromOutputState(state, fileValue->value)); } } if(!patchFile || !file || !out) { XLOG(0, "file error\n"); exit(0); } if(patch(file, out, patchFile) != 0) { XLOG(0, "patch failed\n"); exit(0); } if(strstr(fileValue->value, "WTF.s5l8900xall.RELEASE")) { XLOG(0, "Exploiting 8900 vulnerability... ;)\n"); AbstractFile* exploited; if(useMemory) { exploited = createAbstractFileFrom8900(createAbstractFileFromMemoryFile((void**)&buffer, &bufferSize)); } else { exploited = createAbstractFileFrom8900(createAbstractFileFromFile(fopen(tmpFileName, "r+b"))); } exploit8900(exploited); exploited->close(exploited); } XLOG(0, "writing... "); fflush(stdout); if(useMemory) { addToOutput(state, fileValue->value, buffer, bufferSize); } else { outRaw = createAbstractFileFromFile(fopen(tmpFileName, "rb")); size_t length = outRaw->getLength(outRaw); outRaw->close(outRaw); addToOutput2(state, fileValue->value, NULL, length, tmpFileName); } XLOG(0, "success\n"); fflush(stdout); free(patchPath); return 0; }
/* Worker should: * 0. Get the bounds from the master * 1. Receive a message for the total number of rounds * 2. Wait for a message with the centroids * 3. Perform work to calculate the new centroids * 4. Send a message back with the new centroids * 5. Repeat 2 through 4 for the number of rounds found in 1 */ void runWorker(int rank){ int bounds[2]; int numRounds = 0; int numCentroids; int strandLength; Strand* centroids; Histogram* hists; FILE* tempFile; char fileName[30]; worker_getBounds(bounds); sprintf(fileName,"temp%d_%d",bounds[0], bounds[1]); //Create a temporary file (if it doesn't already exist) to //store the points used by this worker and open it tempFile = createTempFile(fileName,bounds); numRounds = worker_getNumRounds(); // printf("Got num rounds %d\n",rank); numCentroids = worker_getNumCentroids(); // printf("Got %d for num centroids\n %d",numCentroids, rank); strandLength = worker_getStrandLength(); centroids = malloc(sizeof(Strand) * numCentroids); int i; for(i = 0; i < numCentroids; i++) { centroids[i]= malloc(sizeof(base) * strandLength); } if(centroids == null){ printf("Couldn't malloc!\n\n"); return; } hists = malloc(sizeof(Histogram) * numCentroids); for(i = 0; i < numCentroids; i++) { hists[i]= getEmptyHist(strandLength); } if(hists == null){ printf("null from malloc!\n"); return; } for(i = 0; i < numRounds; i++){ printf("worker starting round %d!\n",i); worker_getCentroids(numCentroids, centroids, strandLength); int j; // for(j=0;j<numCentroids;j++){ // printf("received centroids at %e,%e \n",centroids[j].x,centroids[j].y); // } worker_calculateCentroidData(tempFile,centroids,numCentroids, strandLength, hists); printf("farting\n"); worker_sendCentroidData(numCentroids, hists,strandLength); printf("worker done with round %d!\n",i); } //Cleanup // fclose(tempFile); // free(centroids); // free(data); }
int main(int ac, char *av[]) { //TODO extract the serial port codes into another source file, this is too ugly! uint16_t i, j, len; int16_t res=0, result=0; uint8_t destination_ip[32]; uint8_t outbuf[512]; uint8_t linebuf[32]; uint8_t local_filename[32]="\0"; FILE* sptr; if(ac == 1) usage(); //for(i=0; i<ac; i++) // printf("%s\n",av[i]); if(!strcmp("uhf", av[1])) { mode=RADIOTFTP_MODE_UHF; preamble_length=RADIOTFTP_BIM2A_PREAMBLE_LENGTH; baud=RADIOTFTP_BIM2A_BAUD_RATE; printf("Running with UHF band 19200 baud version\n"); openLogFile(RADIOTFTP_BIM2A_EVENTLOG); } else if(!strcmp("vhf", av[1])) { mode=RADIOTFTP_MODE_VHF; preamble_length=RADIOTFTP_UHX1_PREAMBLE_LENGTH; baud=RADIOTFTP_UHX1_BAUD_RATE; printf("Running with VHF band 2400 baud version\n"); openLogFile(RADIOTFTP_UHX1_EVENTLOG); } else if(!strcmp("serial", av[1])) { mode=RADIOTFTP_MODE_SERIAL; preamble_length=RADIOTFTP_SERIAL_PREAMBLE_LENGTH; baud=RADIOTFTP_SERIAL_BAUD_RATE; printf("Couldn't understand the uhf/vhf mode: using %d mode\n", mode); printf("Running with NO BAND %d baud version\n", baud); printf("Opening file %s for logging\n",RADIOTFTP_SERIAL_EVENTLOG); openLogFile(RADIOTFTP_SERIAL_EVENTLOG); } else { printf("Mode not entered, exiting...\n"); return 0; } //setting defaults udp_get_broadcast_ip(destination_ip); strcpy(dial_tty, "/dev/ttyUSB0"); //scanning command line parameters for(i=2; (i < ac) && (av[i][0] == '-'); i++) { if(strcmp(av[i], "-b") == 0) { background=1; } else if(strncmp(av[i], "-f", 2) == 0) { strncpy(local_filename, av[i] + 2, 32); printf("different filename = '%s'\n", local_filename); } else if(strncmp(av[i], "-dst", 4) == 0) { memset(destination_ip, 0, 32); memcpy(destination_ip, av[i] + 4, strlen(av[i]) - 4); /*! convert text ip to numerical */ text_to_ip(destination_ip, strlen(av[i]) - 4 + 1); printf("Destination: "); print_addr_dec(destination_ip); } else { printf("unknown parameter: %s\n", av[i]); usage(); } } res=0; result=0; strncpy(dial_tty, devtag_get(av[i]), sizeof(dial_tty)); while(!get_lock(dial_tty)) { if(decrementLockRetries() == 0) exit(-1); sleep(1); } if((serialportFd=open(devtag_get(av[i]), O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) { perror("bad terminal device, try another"); exit(-1); } signal(SIGIO, SIG_IGN); signal(SIGINT, sigINT_handler); // Make the file descriptor asynchronous (the manual page says only // O_APPEND and O_NONBLOCK, will work with F_SETFL...) fcntl(serialportFd, F_GETFL); fcntl(serialportFd, F_SETFL, O_RDWR | O_SYNC); if(tcgetattr(serialportFd, &tp) < 0) { perror("Couldn't get term attributes"); exit(-1); } old=tp; /* SANE is a composite flag that sets the following parameters from termio(M): CREAD BRKINT IGNPAR ISTRIP ICRNL IXON ISIG ICANON ECHO ECHOK OPOST ONLCR SANE also clears the following modes: CLOCAL IGNBRK PARMRK INPCK INLCR IUCLC IXOFF XCASE ECHOE ECHONL NOFLSH OLCUC OCRNL ONOCR ONLRET OFILL OFDEL NLDLY CRDLY TABDLY BSDLY VTDLY FFDLY */ /* 8 bits + baud rate + local control */ tp.c_cflag=baud | CS8 | CLOCAL | CREAD; tp.c_cflag&=~PARENB; tp.c_cflag&=~CSTOPB; tp.c_cflag&=~CSIZE; tp.c_cflag|=CS8; tp.c_cflag|=CRTSCTS; tp.c_oflag=0; /* Raw Input */ tp.c_lflag=0; /* No conoical */ tp.c_cc[VTIME]=0; tp.c_cc[VMIN]=1; /* ignore CR, ignore parity */ //ISTRIP is a dangerous flag, it strips the 8th bit of bytes //tp.c_iflag= ~( ISTRIP ) | IGNPAR | IGNBRK; tp.c_iflag=~(IGNBRK | PARMRK | INPCK | ISTRIP | INLCR | IUCLC | IXOFF) | BRKINT | IGNPAR | ICRNL | IXON | ISIG | ICANON; /* set output and input baud rates */ cfsetospeed(&tp, baud); cfsetispeed(&tp, baud); tcflush(serialportFd, TCIFLUSH); tcflush(serialportFd, TCOFLUSH); if(tcsetattr(serialportFd, TCSANOW, &tp) < 0) { perror("Couldn't set term attributes"); goto error; } restore=1; //TODO go over the background codes if(background) { int i; if(getppid() == 1) return 0; /* Already a daemon */ i=fork(); if(i < 0) exit(1); /* error */ if(i > 0) _exit(0); /* parent exits */ /* child */ setsid(); /* obtain a new process group */ for(i=getdtablesize(); i >= 0; --i) { if(i == serialportFd) continue; if(i == 1) continue; close(i); /* close all descriptors */ } i=open("/dev/null", O_RDWR); dup(i); dup(i); /* handle standard I/O */ umask(027); /* set newly created file permissions */ chdir("/"); /* change running directory */ } srand((unsigned) time(NULL)); j=0; i++; for(; i < ac; i++) { len=strlen(av[i]); memcpy(command_buffer + j, av[i], len); j+=len; if(i != ac - 1) { command_buffer[j++]=' '; } } //process the escape characters for(i=0; i < j; i++) { if(command_buffer[i] == '\\') { if(i + 1 < j) { if(command_buffer[i + 1] == 'n') { command_buffer[i]='\r'; command_buffer[i + 1]='\n'; } } } } timers_initialize(&sigRTALRM_handler); /*! read settings from radiotftp.conf file */ sptr=fopen("radiotftp.conf", "r"); if(sptr != NULL) { readnline(sptr, linebuf, 32); linebuf[6]=atoi(linebuf + 6); linebuf[8]=0; printf("AX.25 Callsign: "); print_callsign(linebuf); #if AX25_ENABLED==1 ax25_initialize_network(linebuf); printf("USING AX25 LINK LAYER!!!\n"); #else AX25_ENABLED==0 printf("NOT USING ANY LINK LAYER!!!\n"); #endif readnline(sptr, linebuf, 32); text_to_ip(linebuf, strlen(linebuf)); printf("IPv4 Address: "); print_addr_dec(linebuf); udp_initialize_ip_network(linebuf, &queueSerialData); } else { #if AX25_ENABLED==1 ax25_initialize_network(my_ax25_callsign); printf("AX.25 CALLSIGN = "); print_callsign(ax25_get_local_callsign(NULL)); #endif udp_initialize_ip_network(my_ip_address, &queueSerialData); printf("IPv4 Address = "); print_addr_dec(udp_get_localhost_ip(NULL)); } switch(mode) { case RADIOTFTP_MODE_UHF: tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_BIM2A_ACK_TIMEOUT_MIN, RADIOTFTP_BIM2A_ACK_TIMEOUT_MAX, RADIOTFTP_BIM2A_READ_TIMEOUT); break; case RADIOTFTP_MODE_VHF: tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_UHX1_ACK_TIMEOUT_MIN, RADIOTFTP_UHX1_ACK_TIMEOUT_MAX, RADIOTFTP_UHX1_READ_TIMEOUT); break; case RADIOTFTP_MODE_SERIAL: tftp_initialize(udp_get_data_queuer_fptr(), RADIOTFTP_SERIAL_ACK_TIMEOUT_MIN, RADIOTFTP_SERIAL_ACK_TIMEOUT_MAX, RADIOTFTP_SERIAL_READ_TIMEOUT); break; default: perror("unknown baud rate"); safe_exit(-1); break; } if(!strncasecmp(RADIOTFTP_COMMAND_PUT, command_buffer, strlen(RADIOTFTP_COMMAND_PUT))) { printf(RADIOTFTP_COMMAND_PUT"\n"); registerEvent(RADIOTFTP_COMMAND_PUT, command_buffer + strlen(RADIOTFTP_COMMAND_PUT) + 1); if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_PUT) + 1, j - strlen(RADIOTFTP_COMMAND_PUT) - 1, 0))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } else if(!strncasecmp(RADIOTFTP_COMMAND_BEACON, command_buffer, strlen(RADIOTFTP_COMMAND_BEACON))) { printf(RADIOTFTP_COMMAND_BEACON"\n"); registerEvent(RADIOTFTP_COMMAND_BEACON, command_buffer + strlen(RADIOTFTP_COMMAND_BEACON) + 1); if((res=tftp_sendSingleBlockData(destination_ip, command_buffer + strlen(RADIOTFTP_COMMAND_BEACON) + 1, j - strlen(RADIOTFTP_COMMAND_BEACON) - 1, local_filename))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } else if(!strncasecmp(RADIOTFTP_COMMAND_APPEND_LINE, command_buffer, strlen(RADIOTFTP_COMMAND_APPEND_LINE))) { printf(RADIOTFTP_COMMAND_APPEND_LINE"\n"); registerEvent(RADIOTFTP_COMMAND_APPEND_LINE, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_LINE) + 1); i=createTempFile(TEMPFILE_PREFIX, TEMPFILE_POSTFIX); if(tempFile == NULL) { perror("couldn't create temp file to store the line feed"); goto error; } fwrite(command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_LINE) + 1, 1, j - strlen(RADIOTFTP_COMMAND_APPEND_LINE) - 1, tempFile); fflush(tempFile); fclose(tempFile); printf("tempfileName=%s\nlocal_filename=%s\n", tempFileName, local_filename); if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, tempFileName, local_filename, strlen(local_filename), 1))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } else if(!strncasecmp(RADIOTFTP_COMMAND_APPEND_FILE, command_buffer, strlen(RADIOTFTP_COMMAND_APPEND_FILE))) { printf(RADIOTFTP_COMMAND_APPEND_FILE"\n"); registerEvent(RADIOTFTP_COMMAND_APPEND_FILE, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_FILE) + 1); if((res=tftp_sendRequest(TFTP_OPCODE_WRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_APPEND_FILE) + 1, j - strlen(RADIOTFTP_COMMAND_APPEND_FILE) - 1, 1))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } else if(!strncasecmp(RADIOTFTP_COMMAND_GET, command_buffer, strlen(RADIOTFTP_COMMAND_GET))) { printf(RADIOTFTP_COMMAND_GET"\n"); registerEvent(RADIOTFTP_COMMAND_GET, command_buffer + strlen(RADIOTFTP_COMMAND_GET) + 1); if((res=tftp_sendRequest(TFTP_OPCODE_RRQ, destination_ip, local_filename, command_buffer + strlen(RADIOTFTP_COMMAND_GET) + 1, j - strlen(RADIOTFTP_COMMAND_GET) - 1, 0))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } else { printf("hello radio world!\n"); registerEvent("helloWorld", ""); if((res=queueSerialData(udp_get_localhost_ip(NULL), HELLO_WORLD_PORT, udp_get_broadcast_ip(NULL), HELLO_WORLD_PORT, "hello world\n\0x00", strlen("hello world\n\0x00")))) { printf("%d\n", res); perror("tftp request fail"); goto error; } } int sync_counter=0; int sync_passed=0; int save_index=0; //entering the main while loop printf("started listening...\n"); while(1) { if(timer_flag) { idle_timer_handler(); tftp_timer_handler(); timer_flag=0; } if(idle_flag) { //print_time("System Idle"); idle_flag=0; } if(queue_flag) { // printf("queue flag\n"); if(!sync_passed && sync_counter < 1) { //wait_some switch(mode) { case RADIOTFTP_MODE_UHF: usleep(RADIOTFTP_BIM2A_TX_MESSAGE_INTERVAL); break; case RADIOTFTP_MODE_VHF: usleep(RADIOTFTP_UHX1_TX_MESSAGE_INTERVAL); break; case RADIOTFTP_MODE_SERIAL: usleep(RADIOTFTP_SERIAL_TX_MESSAGE_INTERVAL); break; default: perror("unknown baud rate"); safe_exit(-1); break; } transmitSerialData(); queue_flag=0; } } if((res=read(serialportFd, io, IO_BUFSIZE)) > 0) { io_index=0; //printf("# of bytes read = %d\n", res); for(i=0; i < res; i++) { //putchar(io[i]); //printf("%\n",io[i]); if(sync_counter < SYNC_LENGTH && io[i] == syncword[sync_counter]) { sync_counter++; /* sync continued */ //printf("sync counting %d\n",sync_counter); } else { //printf("sync reset %d\n",sync_counter); sync_counter=0; /* not a preamble, reset counter */ } if(sync_counter >= SYNC_LENGTH && sync_passed == 0) { /* preamble passed */ sync_passed=1; } if(sync_passed) { //printf("getting data '%c'\n", io[i]); if(io[i] == END_OF_FILE && !isManchester_encoded(io[i])) { // printf("non-manchester character received\n"); outbuf[0]=0; result=manchester_decode(buf + 1, manchester_buffer, save_index); #if AX25_ENABLED==1 result=ax25_open_ui_packet(NULL, NULL, ax25_buffer, manchester_buffer, result); #else result=1; #endif if(result) { // printf("opened link-layer packet\n"); #if AX25_ENABLED==1 result=udp_open_packet(udp_src, &udp_src_prt, udp_dst, &udp_dst_prt, udp_buffer, ax25_buffer); #else result = udp_open_packet(udp_src, &udp_src_prt, udp_dst, &udp_dst_prt, udp_buffer, manchester_buffer); #endif if(result) { // printf("opened transport-layer packet\n"); udp_packet_demultiplexer(udp_src, udp_src_prt, udp_dst, udp_dst_prt, udp_buffer, result); } else { strcat(outbuf, "!udp discarded!"); if(write(1, outbuf, strlen(outbuf)) <= 0) { fputs("couldn't write to tty\n", stderr); } if(write(1, "\n", 1) <= 0) { fputs("couldn't write to tty\n", stderr); } } } else { strcat(outbuf, "!ax25 discarded!"); if(write(1, outbuf, strlen(outbuf)) <= 0) { fputs("couldn't write to tty\n", stderr); } if(write(1, "\n", 1) <= 0) { fputs("couldn't write to tty\n", stderr); } } sync_passed=0; sync_counter=0; save_index=0; } else { // printf("saved data '%c'\n", io[i]); // printf("save_index=%d/%d\n",save_index, sizeof(buf)); if(save_index >= sizeof(buf)) { sync_passed=0; sync_counter=0; save_index=0; } buf[save_index++]=io[i]; buf[save_index + 1]=0; // printf("-\n%s\n-\n", buf); } } } io_flag=0; } } safe_exit(0); error: safe_exit(-1); return -2; }
TemporaryFile::TemporaryFile (const String& suffix, const int optionFlags) : temporaryFile (createTempFile (File::getSpecialLocation (File::tempDirectory), "temp_" + String::toHexString (Random::getSystemRandom().nextInt()), suffix, optionFlags)) { }
QgsRasterLayer* QgsRemoteOWSBuilder::wcsLayerFromUrl( const QString &url, const QString &layerName, QList<QTemporaryFile*> &filesToRemove, QList<QgsMapLayer*> &layersToRemove, bool allowCaching ) const { Q_UNUSED( layerName ); Q_UNUSED( allowCaching ); #if QT_VERSION < 0x050000 QgsDebugMsg( "Entering" ); //write server url and coverage name to a temporary file QString fileName = createTempFile(); if ( fileName.isEmpty() ) { return nullptr; } QFile tempFile( fileName ); QTemporaryFile* tmpFile = new QTemporaryFile(); if ( !tmpFile->open() ) { delete tmpFile; return nullptr; } filesToRemove.push_back( tmpFile ); //make sure the temporary file gets deleted after each request QgsDebugMsg( "opening successful" ); QgsDebugMsg( "url: " + url ); //extract server url and coverage name from string QStringList serverSplit = url.split( "?" ); if ( serverSplit.size() < 2 ) { QgsDebugMsg( "error, no '?' contained in url" ); return nullptr; } QString serverUrl = serverSplit.at( 0 ); QString request = serverSplit.at( 1 ); QStringList parameterSplit = request.split( "&" ); QString coverageName; QString format; for ( int i = 0; i < parameterSplit.size(); ++i ) { if ( parameterSplit.at( i ).startsWith( "COVERAGE", Qt::CaseInsensitive ) ) { coverageName = parameterSplit.at( i ).split( "=" ).at( 1 ); } else if ( parameterSplit.at( i ).startsWith( "FORMAT", Qt::CaseInsensitive ) ) { format = parameterSplit.at( i ).split( "=" ).at( 1 ); } } if ( coverageName.isEmpty() ) { QgsDebugMsg( "coverage name is empty" ); return nullptr; } if ( format.isEmpty() ) { format = "GeoTIFF"; //use geotiff as default } QgsDebugMsg( "wcs server url: " + serverUrl ); QgsDebugMsg( "coverage name: " + coverageName ); //fetch WCS layer in the current resolution as geotiff QString wcsRequest = serverUrl + "?SERVICE=WCS&VERSION=1.0.0&REQUEST=GetCoverage&COVERAGE=" + coverageName + "&FORMAT=" + format; //CRS (or SRS) QString crs = mParameterMap.value( "CRS", mParameterMap.value( "SRS" ) ); if ( crs.isEmpty() ) { QgsDebugMsg( "No CRS or SRS parameter found for wcs layer, returning 0" ); return nullptr; } wcsRequest += "&CRS=" + crs; //width QString width = mParameterMap.value( "WIDTH" ); if ( width.isEmpty() ) { QgsDebugMsg( "No WIDTH parameter found for wcs layer, returning 0" ); return nullptr; } wcsRequest += "&WIDTH=" + width; //height QString height = mParameterMap.value( "HEIGHT" ); if ( height.isEmpty() ) { QgsDebugMsg( "No HEIGHT parameter found for wcs layer, returning 0" ); return nullptr; } wcsRequest += "&HEIGHT=" + height; //bbox QString bbox = mParameterMap.value( "BBOX" ); if ( bbox.isEmpty() ) { QgsDebugMsg( "No BBOX parameter found for wcs layer, returning 0" ); return nullptr; } wcsRequest += "&BBOX=" + bbox; QgsDebugMsg( "WCS request is: " + wcsRequest ); //make request and store byte array into temporary file QgsHttpTransaction httpTransaction( wcsRequest ); QByteArray result; if ( !httpTransaction.getSynchronously( result ) ) { return nullptr; } QDataStream tempFileStream( &tempFile ); tempFileStream.writeRawData( result.data(), result.size() ); tempFile.close(); QgsRasterLayer* rl = new QgsRasterLayer( fileName, layerNameFromUri( fileName ) ); layersToRemove.push_back( rl ); //make sure the layer gets deleted after each request return rl; #else Q_UNUSED( url ) Q_UNUSED( filesToRemove ) Q_UNUSED( layersToRemove ) QgsDebugMsg( "remote http not supported with Qt5" ); return nullptr; #endif }
int doDecrypt(StringValue* decryptValue, StringValue* fileValue, const char* bundlePath, OutputState** state, unsigned int* key, unsigned int* iv, int useMemory) { size_t bufferSize; void* buffer; AbstractFile* file; AbstractFile* out; AbstractFile* outRaw; char* tmpFileName; if(useMemory) { bufferSize = 0; buffer = malloc(1); outRaw = createAbstractFileFromMemoryFile((void**)&buffer, &bufferSize); } else { tmpFileName = createTempFile(); outRaw = createAbstractFileFromFile(fopen(tmpFileName, "wb")); } out = duplicateAbstractFile(getFileFromOutputState(state, fileValue->value), outRaw); file = openAbstractFile3(getFileFromOutputState(state, fileValue->value), key, iv, 0); if(!file || !out) { XLOG(0, "file error\n"); exit(0); } char *buf = malloc(1024 * 1024); off_t inDataSize = file->getLength(file); while (inDataSize > 0) { off_t avail, chunk = 1024 * 1024; if (chunk > inDataSize) { chunk = inDataSize; } if (chunk < 0) { XLOG(0, "decrypt failed\n"); exit(0); } avail = file->read(file, buf, chunk); out->write(out, buf, avail); if (avail < chunk) { break; } inDataSize -= chunk; } out->close(out); file->close(file); free(buf); XLOG(0, "writing... "); fflush(stdout); if (decryptValue) { fileValue = decryptValue; } if(useMemory) { addToOutput(state, fileValue->value, buffer, bufferSize); } else { outRaw = createAbstractFileFromFile(fopen(tmpFileName, "rb")); size_t length = outRaw->getLength(outRaw); outRaw->close(outRaw); addToOutput2(state, fileValue->value, NULL, length, tmpFileName); } XLOG(0, "success\n"); fflush(stdout); return 0; }
int HPCupsFilter::processRasterData(cups_raster_t *cups_raster) { FILE *kfp = NULL; FILE *cfp = NULL; BYTE *kRaster = NULL; BYTE *rgbRaster = NULL; int current_page_number = 0; cups_page_header2_t cups_header; DRIVER_ERROR err; int ret_status = 0; char hpPreProcessedRasterFile[MAX_FILE_PATH_LEN]; //temp file needed to store raster data with swaped pages. sprintf(hpPreProcessedRasterFile, "%s/hp_%s_cups_SwapedPagesXXXXXX",CUPS_TMP_DIR, m_JA.user_name); while (cupsRasterReadHeader2(cups_raster, &cups_header)) { current_page_number++; if (current_page_number == 1) { if (startPage(&cups_header) != NO_ERROR) { return JOB_CANCELED; } if (m_JA.pre_process_raster) { // CC ToDo: Why pSwapedPagesFileName should be sent as a parameter? // Remove if not required to send it as parameter err = m_Job.preProcessRasterData(&cups_raster, &cups_header, hpPreProcessedRasterFile); if (err != NO_ERROR) { if (m_iLogLevel & BASIC_LOG) { dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err); } ret_status = JOB_CANCELED; break; } } if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) { rgbRaster = new BYTE[cups_header.cupsWidth * 3]; if (rgbRaster == NULL) { return ALLOCMEM_ERROR; } kRaster = new BYTE[cups_header.cupsWidth]; if (kRaster == NULL) { delete [] rgbRaster; return ALLOCMEM_ERROR; } memset (kRaster, 0, cups_header.cupsWidth); memset (rgbRaster, 0xFF, cups_header.cupsWidth * 3); } } // end of if(current_page_number == 1) if (cups_header.cupsColorSpace == CUPS_CSPACE_K) { kRaster = m_pPrinterBuffer; rgbRaster = NULL; } else if (cups_header.cupsColorSpace != CUPS_CSPACE_RGBW) { rgbRaster = m_pPrinterBuffer; kRaster = NULL; } BYTE *color_raster = NULL; BYTE *black_raster = NULL; err = m_Job.StartPage(&m_JA); if (err != NO_ERROR) { if (m_iLogLevel & BASIC_LOG) { dbglog ("DEBUG: Job::StartPage failed with err = %d\n", err); } ret_status = JOB_CANCELED; break; } // Save Raster file for Debugging if (m_iLogLevel & SAVE_INPUT_RASTERS) { char szFileName[MAX_FILE_PATH_LEN]; memset(szFileName, 0, sizeof(szFileName)); if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW || cups_header.cupsColorSpace == CUPS_CSPACE_RGB) { snprintf (szFileName, sizeof(szFileName), "%s/hpcups_%s_c_bmp_%d_XXXXXX", CUPS_TMP_DIR, m_JA.user_name, current_page_number); createTempFile(szFileName, &cfp); if (cfp) { chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); } } if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW || cups_header.cupsColorSpace == CUPS_CSPACE_K) { snprintf (szFileName, sizeof(szFileName), "%s/hpcups_%s_k_bmp_%d_XXXXXX", CUPS_TMP_DIR, m_JA.user_name, current_page_number); createTempFile(szFileName, &kfp); if (kfp) { chmod (szFileName, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); } } WriteBMPHeader (cfp, cups_header.cupsWidth, cups_header.cupsHeight, COLOR_RASTER); WriteBMPHeader (kfp, cups_header.cupsWidth, cups_header.cupsHeight, BLACK_RASTER); } fprintf(stderr, "PAGE: %d %s\r\n", current_page_number, m_argv[4]); // Iterating through the raster per page bool is_ljmono = strcmp(m_JA.printer_language, "ljmono"); for (int y = 0; y < (int) cups_header.cupsHeight; y++) { cupsRasterReadPixels (cups_raster, m_pPrinterBuffer, cups_header.cupsBytesPerLine); color_raster = rgbRaster; black_raster = kRaster; if ((y == 0) && !is_ljmono) { //For ljmono, make sure that first line is not a blankRaster line.Otherwise printer //may not skip blank lines before actual data //Need to revisit to cross check if it is a firmware issue. *m_pPrinterBuffer = 0x01; dbglog("First raster data plane..\n" ); } if (this->isBlankRaster((BYTE *) m_pPrinterBuffer, &cups_header)) { color_raster = NULL; black_raster = NULL; } extractBlackPixels(&cups_header, black_raster, color_raster); //! Sending Raster bits off to encapsulation err = m_Job.SendRasters (black_raster, color_raster); if (err != NO_ERROR) { break; } if (m_iLogLevel & SAVE_INPUT_RASTERS) { WriteBMPRaster (cfp, color_raster, cups_header.cupsWidth, COLOR_RASTER); WriteBMPRaster (kfp, black_raster, cups_header.cupsWidth/8, BLACK_RASTER); } } // for() loop end m_Job.NewPage(); if (err != NO_ERROR) { break; } } // while() loop end //! Remove the old processing band data... if (cups_header.cupsColorSpace == CUPS_CSPACE_RGBW) { delete [] kRaster; delete [] rgbRaster; kRaster = NULL; rgbRaster = NULL; } unlink(hpPreProcessedRasterFile); return ret_status; }