Пример #1
0
FileTransferHandler::FileTransferHandler(PsiAccount *pa, FileTransfer *ft)
{
	d = new Private;
	d->pa = pa;
	d->c = 0;

	if(ft) {
		d->sending = false;
		d->peer = ft->peer();
		d->fileName = clean_filename(ft->fileName());
		d->fileSize = ft->fileSize();
		d->desc = ft->description();
		d->shift = calcShift(d->fileSize);
		d->complement = calcComplement(d->fileSize, d->shift);
		d->ft = ft;
		Jid proxy = d->pa->userAccount().dtProxy;
		if(proxy.isValid())
			d->ft->setProxy(proxy);
		mapSignals();
	}
	else {
		d->sending = true;
		d->ft = 0;
	}
}
Пример #2
0
void _vm_free( void *ptr )
#endif
{
	if (!ptr)
	{
#ifndef NDEBUG
			mprintf(("Why are you trying to free a NULL pointer?  [%s(%d)]\n", clean_filename(filename), line));
#else
			mprintf(("Why are you trying to free a NULL pointer?\n"));
		#endif
		return;
	}



#ifndef NDEBUG
	_CrtMemBlockHeader* phd = pHdr(ptr);
	int nSize = phd->nDataSize;

	TotalRam -= nSize;
	if (Cmdline_show_mem_usage)
		unregister_malloc(filename, nSize, ptr);
#endif

	_free_dbg(ptr, _NORMAL_BLOCK);
}
Пример #3
0
void *_vm_realloc( void *ptr, int size, int quiet )
#endif
{
	if (ptr == NULL)
		return vm_malloc(size);

#ifndef NDEBUG
	size_t old_size = MALLOC_USABLE(ptr);
#endif

	void *ret_ptr = realloc( ptr, size );

	if (!ret_ptr)	{
		if (quiet && (size > 0) && (ptr != NULL)) {
			// realloc doesn't touch the original ptr in the case of failure so we could still use it
			return NULL;
		}

		Error(LOCATION, "Out of memory.");
	}

#ifndef NDEBUG
	size_t used_size = MALLOC_USABLE(ret_ptr);
	if ( Watch_malloc )	{
		// mprintf now uses SCP_strings = recursion! Whee!!
		fprintf( stdout, "Realloc %zu bytes [%s(%d)]\n", used_size, clean_filename(filename), line );
	}

	TotalRam += (used_size - old_size);
#endif

	return ret_ptr;
}
Пример #4
0
void create_ce_statistics (
    char *ce,
    char *c,
    char *file
    )
{
    file_stat *fs;
    char *fn;
    component_stat *cs;

    fn = clean_filename (file);
    cs = find_component (component);
    if (cs) {
	fs = find_filestat (cs, fn);
	if (fs == NULL) {
	    fs = malloc (sizeof (file_stat));
	    memset (fs, 0, sizeof (file_stat));
	    fs->name = f_strdup(fn);
	    if (cs->stat == NULL) {
		cs->stat = fs;
	    } else {
		fs->next = cs->stat;
		cs->stat = fs;
	    }
	}
    }
    sscanf (ce, "%f", &fs->ce);
    sscanf (c, "%d", &fs->c);
}
Пример #5
0
void *_vm_malloc( int size, int quiet )
#endif
{
	void *ptr = malloc( size );

	if (!ptr)	{
		if (quiet) {
			return NULL;
		}

		Error(LOCATION, "Out of memory.");
	}

#ifndef NDEBUG
	size_t used_size = MALLOC_USABLE(ptr);
	if ( Watch_malloc )	{
		// mprintf now uses SCP_strings = recursion! Whee!!
		fprintf( stdout, "Malloc %zu bytes [%s(%d)]\n", used_size, clean_filename(filename), line );
	}

	TotalRam += used_size;
#endif

	return ptr;
}
Пример #6
0
bool spifs_unlink(const char *filename)
{
    int16_t fileId;
    char cleanname[SPIFS_FILENAME_LEN];
    SPIFlash handler;

    // Clean the filename of problem characters.
    if (!clean_filename(filename, cleanname)) return false;

    // Wait for exclusive access to the SPI master bus.
    osMutexWait(spiMasterMutex, osWaitForever);

    // Open the SPI flash device.
    spi_flash_open(SPI0, SPI_MODE0, false, Freq_1Mbps, &handler);

    // Find a file id associated with the filename.
    fileId = spifs_find_filename(&handler, cleanname);

    // Erase each fileblock associated with the file.
    if (SPIFS_FILEID_VALID(fileId)) spifs_erase_blocks(&handler, fileId);

    // Close the SPI flash device.
    spi_flash_close(&handler);

    // Release exclusive access to the SPI master bus.
    osMutexRelease(spiMasterMutex);

    return true;
}
Пример #7
0
    virtual void OnEntry( void* address, const char* module, const char* symbol )
    {
        UNREFERENCED_PARAMETER( address );

        StackEntry entry;
        entry.module = clean_filename( module );
        entry.symbol = symbol;
        m_stackFrames.push_back( entry );
    }
Пример #8
0
		void Error(const char * filename, int line, const char * format, ...)
		{
			SCP_string formatText;
			filename = clean_filename(filename);

			va_list args;
			va_start(args, format);
			vsprintf(formatText, format, args);
			va_end(args);

			SCP_stringstream messageStream;
			messageStream << "Error: " << formatText << "\n";
			messageStream << "File: " << filename << "\n";
			messageStream << "Line: " << line << "\n";

			Error(messageStream.str().c_str());
		}
Пример #9
0
void _vm_free( void *ptr )
#endif
{
	if ( !ptr ) {
#ifndef NDEBUG
		mprintf(("Why are you trying to free a NULL pointer?  [%s(%d)]\n", clean_filename(filename), line));
#else
		mprintf(("Why are you trying to free a NULL pointer?\n"));
#endif
		return;
	}

#ifndef NDEBUG
	TotalRam -= MALLOC_USABLE(ptr);
#endif // !NDEBUG

	free(ptr);
}
Пример #10
0
		void AssertMessage(const char * text, const char * filename, int linenum, const char * format, ...)
		{
			// We only want to display the file name
			filename = clean_filename(filename);

			SCP_stringstream msgStream;
			msgStream << "Assert: \"" << text << "\"\n";
			msgStream << "File: " << filename << "\n";
			msgStream << "Line: " << linenum << "\n";
			
			if (format != nullptr)
			{
				SCP_string buffer;
				va_list args;

				va_start(args, format);
				vsprintf(buffer, format, args);
				va_end(args);

				msgStream << buffer << "\n";
				mprintf(("ASSERTION: \"%s\" at %s:%d\n %s\n", text, filename, linenum, buffer.c_str()));
			}
			else
			{
				// No additional message
				mprintf(("ASSERTION: \"%s\" at %s:%d\n", text, filename, linenum));
			}

			if (running_unittests) {
				throw AssertException(msgStream.str());
			}

			msgStream << "\n";
			msgStream << dump_stacktrace();

			SCP_string messageText = msgStream.str();
			set_clipboard_text(messageText.c_str());

			messageText = truncateLines(msgStream, Messagebox_lines);
			messageText += "\n[ This info is in the clipboard so you can paste it somewhere now ]\n";
			messageText += "\n\nUse Debug to break into Debugger, Exit will close the application.\n";

			Error(messageText.c_str());
		}
Пример #11
0
void create_be_statistics (
    char *be,
    char *b,
    char *file
    )
{
    file_stat *fs;
    char *fn;
    component_stat *cs;

    fn = clean_filename (file);
    cs = find_component (component);
    if (cs) {
	fs = find_filestat (cs, fn);
	if (fs == NULL) {
	    fs = malloc (sizeof (file_stat));
	    memset (fs, 0, sizeof (file_stat));
	    fs->name = f_strdup(fn);
	    if (cs->stat == NULL) {
		cs->stat = fs;
	    } else {
		fs->next = cs->stat;
		cs->stat = fs;
	    }
	}
    }
    sscanf (be, "%f", &fs->be);
    sscanf (b, "%d", &fs->b);
#if 0
    if ((fs->be < 80.0) && !(fs->be == 0.0 && fs->sle == 100.0)) {
	cs->files_fail_on_limit++;
    } else {
	cs->files_pass_on_limit++;
	if (missed_functions) {
	    cs->files_fail_untouched_functions++;
	}
    }
    fs->mf = missed_functions;
#endif
}
Пример #12
0
/**
Final preparation for recording.
*/
void IngexRecorder::Setup(
                framecount_t start_timecode,
                const prodauto::ProjectName & project_name)
{
    ACE_DEBUG((LM_DEBUG, ACE_TEXT("IngexRecorder::Setup()\n")));

    // Get ProjectName associated with supplied name.
    //prodauto::ProjectName project_name;
    //GetProjectFromDb(project, project_name);

    // Store project name
    mProjectName = project_name;


    // Get current recorder settings
    RecorderSettings * settings = RecorderSettings::Instance();
    settings->Update(mpImpl->Recorder());

    /*
    switch (settings->timecode_mode)
    {
    case LTC_PARAMETER_VALUE:
        IngexShm::Instance()->TcMode(IngexShm::LTC);
        ACE_DEBUG((LM_DEBUG, ACE_TEXT("LTC mode\n")));
        break;
    case VITC_PARAMETER_VALUE:
        IngexShm::Instance()->TcMode(IngexShm::VITC);
        ACE_DEBUG((LM_DEBUG, ACE_TEXT("VITC mode\n")));
        break;
    default:
        ACE_DEBUG((LM_ERROR, ACE_TEXT("Unexpected timecode mode\n")));
        break;
    }
    */

    //unsigned int n_channels = IngexShm::Instance()->Channels();
    // Tracks per channel
    // e.g. 5 (1 video, 4 audio) or 9 (1 video, 8 audio)
    // A bit dodgy as different inputs on a recorder can have
    // different numbers of tracks.
    //mTracksPerChannel = track_enables.size() / channel_enables.size();

    int first_enabled_channel = -1;
    for (unsigned int i = 0; first_enabled_channel < 0 && i < mChannelEnable.size(); ++i)
    {
        if (mChannelEnable[i])
        {
            first_enabled_channel = i;
        }
    }

    // Create any needed paths.
    // NB. Paths need to be same as those used in recorder_fucntions.cpp
    for (std::vector<EncodeParams>::iterator it = settings->encodings.begin();
        it != settings->encodings.end(); ++it)
    {
        if (USE_PROJECT_SUBDIR)
        {
            std::string project_subdir = mProjectName.name;
            clean_filename(project_subdir);
            it->dir += PATH_SEPARATOR;
            it->dir += project_subdir;
            it->copy_dest += PATH_SEPARATOR;
            it->copy_dest += project_subdir;
        }

        FileUtils::CreatePath(it->dir);

        if (it->file_format == MXF_FILE_FORMAT_TYPE)
        {
            // Make Creating and Failures subdirs for MXF
            std::ostringstream creating_path;
            creating_path << it->dir << PATH_SEPARATOR << settings->mxf_subdir_creating;
            FileUtils::CreatePath(creating_path.str());
            std::ostringstream failures_path;
            failures_path << it->dir << PATH_SEPARATOR << settings->mxf_subdir_failures;
            FileUtils::CreatePath(failures_path.str());
            //std::ostringstream metadata_path;
            //metadata_path << it->dir << PATH_SEPARATOR << settings->mxf_subdir_metadata;
            //FileUtils::CreatePath(metadata_path.str());
        }
        else
        {
            // Make Creating subdir for other formats
            std::ostringstream creating_path;
            creating_path << it->dir << PATH_SEPARATOR << CREATING_SUBDIR;
            FileUtils::CreatePath(creating_path.str());
        }
    }

    // Set up encoding threads
    int encoding_i = 0;
    for (std::vector<EncodeParams>::const_iterator it = settings->encodings.begin();
        it != settings->encodings.end(); ++it, ++encoding_i)
    {
        if (it->source == Input::NORMAL)
        {
            for (unsigned int i = 0; i < mChannelEnable.size(); i++)
            {
                if (mChannelEnable[i])
                {
                    ThreadParam tp;
                    tp.p_rec = this;

                    tp.p_opt = new RecordOptions;
                    tp.p_opt->channel_num = i;
                    tp.p_opt->index = encoding_i;
                    
                    tp.p_opt->resolution = it->resolution;
                    tp.p_opt->file_format = it->file_format;
                    tp.p_opt->bitc = it->bitc;
                    tp.p_opt->dir = it->dir;

                    mThreadParams.push_back(tp);
                }
            }
        }
        else if (it->source == Input::QUAD)
        {
            ThreadParam tp;
            tp.p_rec = this;

            tp.p_opt = new RecordOptions;
            tp.p_opt->channel_num = first_enabled_channel;
            tp.p_opt->index = encoding_i;
            tp.p_opt->quad = true;
            tp.p_opt->resolution = it->resolution;
            tp.p_opt->file_format = it->file_format;
            tp.p_opt->bitc = it->bitc;
            tp.p_opt->dir = it->dir;

            mThreadParams.push_back(tp);
        }
    }
#if 0
// For test only, add a further encoding
    {
        ThreadParam tp;
        tp.p_rec = this;

        tp.p_opt = new RecordOptions;
        tp.p_opt->channel_num = 0;
        tp.p_opt->index = 2;
        
        tp.p_opt->resolution = 8;
        tp.p_opt->file_format = MXF_FILE_FORMAT_TYPE;
        tp.p_opt->bitc = true;
        tp.p_opt->dir = "/video/mxf_offline";

        mThreadParams.push_back(tp);
    }
#endif

    // Create and store filenames based on source, target timecode and date.
    ::Timecode tc(start_timecode, mFps, mDf);
    std::string date = DateTime::DateNoSeparators();
    const char * tcode = tc.TextNoSeparators();

    // We also include project name to help with copying to project-based
    // directories on a file-server.

    // Note that we make sure ident does not contain any unsuitable
    // characters such as '/'

    // Set filename stems in RecordOptions.
    for (std::vector<ThreadParam>::iterator
        it = mThreadParams.begin(); it != mThreadParams.end(); ++it)
    {
        const char * src_name = (it->p_opt->quad ? QUAD_NAME : SOURCE_NAME[it->p_opt->channel_num]);
        std::ostringstream ss;
        ss << date << "_" << tcode
            << "_" << mProjectName.name
            << "_" << mpImpl->Name()
            << "_" << src_name
            << "_" << it->p_opt->index;

        std::string ident = ss.str();
        clean_filename(ident);

        it->p_opt->file_ident = ident;
    }

    // Set up some of the user comments
    mUserComments.clear();
    mUserComments.push_back(
        prodauto::UserComment(AVID_UC_SHOOT_DATE_NAME, date.c_str(), STATIC_COMMENT_POSITION, 0));
}
Пример #13
0
		void ReleaseWarning(const char* filename, int line, const char* format, ...)
		{
			Global_warning_count++;

			filename = clean_filename(filename);

			// output to the debug log before anything else (so that we have a complete record)

			SCP_string formatMessage;
			va_list args;
			va_start(args, format);
			vsprintf(formatMessage, format, args);
			va_end(args);


			SCP_string printfString = formatMessage;
			std::transform(printfString.begin(), printfString.end(), printfString.begin(), replaceNewline);

			mprintf(("WARNING: \"%s\" at %s:%d\n", printfString.c_str(), filename, line));

			// now go for the additional popup window, if we want it ...
			if (Cmdline_noninteractive) {
				return;
			}

			if (running_unittests) {
				throw AssertException(printfString);
			}

			SCP_stringstream boxMsgStream;
			boxMsgStream << "Warning: " << formatMessage << "\n";
			boxMsgStream << "File: " << filename << "\n";
			boxMsgStream << "Line: " << line << "\n";

			boxMsgStream << "\n";
			boxMsgStream << dump_stacktrace();

			set_clipboard_text(boxMsgStream.str().c_str());

			SCP_string boxMessage = truncateLines(boxMsgStream, Messagebox_lines);
			boxMessage += "\n[ This info is in the clipboard so you can paste it somewhere now ]\n";
			boxMessage += "\n\nUse Debug to break into Debugger\n";

			const SDL_MessageBoxButtonData buttons[] = {
				{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 2, "Exit" },
				{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 1, "Continue" },
				{ /* .flags, .buttonid, .text */        0, 0, "Debug" },
			};

			SDL_MessageBoxData boxData;
			memset(&boxData, 0, sizeof(boxData));

			boxData.buttons = buttons;
			boxData.numbuttons = 3;
			boxData.colorScheme = nullptr;
			boxData.flags = SDL_MESSAGEBOX_WARNING;
			boxData.message = boxMessage.c_str();
			boxData.title = "Warning!";
			boxData.window = os::getSDLMainWindow();

			gr_activate(0);

			int buttonId;
			if (SDL_ShowMessageBox(&boxData, &buttonId) < 0)
			{
				// Call failed
				exit(1);
			}

			switch (buttonId)
			{
			case 2:
				exit(1);

			case 0:
				Int3();
				break;

			default:
				break;
			}

			gr_activate(1);
		}
Пример #14
0
/* découpe la commande en mots  et les mettre dans elem
   elem doit se termine par NULL pour execvp
 */
void decoupe_cmd(char line[] , char *elem[]) {
    if (!line) exit;
    char* first = line;
    char* cpt = line;

    if (strchr(line , '&')) en_fond = 1;
    if (strchr(line , '*')) use_glob = 1;

    if (strchr(line , '>')) {
        redirected = 1;
        red_type = STDOUT;
    }
    if (strchr(line , '<')) {
        redirected = 1;
        red_type = STDIN;
    }

    if (strchr(line , '>')==(strrchr(line , '>')-1)) {
        double_redirection = 1;
        printf("first = %d ; last %d",strchr(line , '>') , strrchr(line , '>'));
        fflush(stdout);
    }
    int i;

    if (redirected) {
        if (red_type == STDOUT)first = strtok( line, ">");
        else first = strtok( line, "<");

    }

    if ((redirected && red_type == STDIN)) {
        redirected = 1;
        if (red_file!= NULL ) {
            char *_red_file;
            _red_file = strtok( NULL, "<" );
            red_file = clean_filename(_red_file);

            exit;
        }
    }
    if (redirected && red_type == STDOUT) {
        redirected = 1;

        if (red_file!= NULL ) {
            char *_red_file;


            _red_file = strtok( NULL, ">" );


            red_file = clean_filename(_red_file);
            exit;
        }

    }
    //ligne = strtok(ligne , '|');
    for (i=0;i<MAXELEMS-1; i++) {
        /* saute les espaces */
        while (*first && (isspace(*first) || (*first=='&')))
            first++;
        /* fin de ligne ? */
        if (!*first) break;
        /* on se souvient du début de ce mot */
        elem[i] = first;
        cpt = first;

        /* cherche la fin du mot */
        while (*cpt && !isspace(*cpt) )
            cpt++; /* saute le mot */

        /* termine le mot par un \0 et passe au suivant */
        if (*cpt) {
            *cpt = 0;
            cpt++;
        }
        first = cpt;
    }

    elem[i] = NULL; // le dernier doit etre NULL pour execvp

    if ((i!=0)&&(((strncmp(elem[0],"ls", 2))==0)||((strncmp(elem[0],"grep", 4))==0))) { //Ajouter la colorisation
        int fin = 0;
        char* temp;
        do {
            fin++;
        } while (elem[fin]!=NULL);
        int i;
        for (i=fin;i>1;i--)
            elem[i]=elem[i-1];
        elem[1]="--color=auto";
        elem[fin+1] = NULL;
    }

}
Пример #15
0
// Open the named file for reading or writing.
bool spifs_open(const char *filename, bool write, SPIFSFile *file)
{
    bool retval;
    int16_t fileId;
    uint32_t sectorOffset;
    SPIFSFileBlock fileBlock;
    SPIFlash handler;
    char cleanname[SPIFS_FILENAME_LEN];

    // Assume we fail.
    retval = false;

    // Initialize the file structure.
    memset(file, 0, sizeof(SPIFSFile));

    // Clean the filename of problem characters.
    if (!clean_filename(filename, cleanname)) return false;

    // Wait for exclusive access to the SPI master bus.
    osMutexWait(spiMasterMutex, osWaitForever);

    // Open the SPI flash device.
    spi_flash_open(SPI0, SPI_MODE0, false, Freq_1Mbps, &handler);

    // Get the file id of any file with the same filename.
    fileId = spifs_find_filename(&handler, cleanname);

    // Are we opening the file for writing?
    if (write)
    {
        // Erase each fileblock associated with the existing file.
        if (SPIFS_FILEID_VALID(fileId)) spifs_erase_blocks(&handler, fileId);

        // Find a free sector.
        fileId = spifs_free_block(&handler);

        // Did we find a free sector?
        if (SPIFS_FILEID_VALID(fileId))
        {
            // Prepare the sector for writing.
            file->write = true;
            file->fileId = fileId;
            file->blockId = 0;
            file->blockSize = SPIFS_FILENAME_LEN;
            file->blockIndex = SPIFS_FILENAME_LEN;
            file->thisId = fileId;
            file->nextId = -1;
            file->position = SPIFS_FILENAME_LEN;

            // Get the byte offset of the sector at the start of the file.
            // The sector id is equal to the file id.
            sectorOffset = SPIFS_SECTORID_TO_BYTEOFFSET(fileId);

            // Write the file id.
            spi_flash_write(&handler, sectorOffset + SPIFS_FILEID_OFFSET, (uint8_t *) &file->fileId, sizeof(int16_t));

            // Write the block id.
            spi_flash_write(&handler, sectorOffset + SPIFS_BLOCKID_OFFSET, (uint8_t *) &file->blockId, sizeof(int16_t));

            // Write the file name.
            spi_flash_write(&handler, sectorOffset + SPIFS_FILENAME_OFFSET, (uint8_t *) cleanname, SPIFS_FILENAME_LEN);

            // We won't write the other header information until we begin
            // writing the next file block or the file is closed.

            // We succeeded opening the file for writing.
            retval = true;
        }
    }
    else
    {
        // If we are reading a file we must have a valid file id.
        if (SPIFS_FILEID_VALID(fileId))
        {
            // Get the byte offset of the sector at the start of the file.
            // The sector id is equal to the file id.
            sectorOffset = SPIFS_SECTORID_TO_BYTEOFFSET(fileId);

            // Read in the first block header.
            spi_flash_read(&handler, sectorOffset, (uint8_t *) &fileBlock, sizeof(fileBlock));

            // Initialize the file structure.
            file->write = false;
            file->fileId = fileBlock.fileId;
            file->blockId = fileBlock.blockId;
            file->blockSize = fileBlock.blockSize;
            file->blockIndex = SPIFS_FILENAME_LEN;
            file->thisId = fileBlock.fileId;
            file->nextId = fileBlock.nextId;
            file->position = SPIFS_FILENAME_LEN;

            // Sanity check the block size.
            if (!SPIFS_BLOCKSIZE_VALID(file->blockSize)) file->blockSize = SPIFS_BLOCK_SIZE;

            // We succeeded opening the file for reading.
            retval = true;
        }
    }

    // Close the SPI flash device.
    spi_flash_close(&handler);

    // Release exclusive access to the SPI master bus.
    osMutexRelease(spiMasterMutex);

    return retval;
}