begin process at 2008 07 19 09:21:52
1 212 728 membres
67 nouveaux aujourd'hui
14 165 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

TRONQUER UN FICHIER(C - WINDOWS)


Information sur la source

Catégorie :API Classé sous : tronquer, fichier, windows, win32, mapping Niveau : Débutant Date de création : 03/04/2005 Date de mise à jour : 18/05/2007 01:44:37 Vu : 5 551

Note :
Aucune note

Commentaire sur cette source (2)
Ajouter un commentaire et/ou une note

Description

Suite à un problème/demande via le forum: http://www.cppfrance.com/forum.v2.aspx?rm=1&ID=422230

Permet de tronquer un fichier
    - modifier sa taille
    - retirer X octet(s) dans le fichier(à un endroit quelconque)

cet exemple utilise l'API Windows(directement).

CreateFile(), CreateFileMapping(), MapViewOfFile(), UnmapViewOfFile(),
FlushViewOfFile(), SetFilePointer(), SetEndOfFile(), GetFileSize(),
CloseHandle() et GetLastError().

Il y à aussi une gestion des exceptions en C avec __try/__except pour
les compilateurs les supportants.

Les trois fonctions utilise des entiers 64bits(LONGLONG) pour les fichiers
de plus de 4go, donc, il supporte les fichiers de toutes les tailles.

Le code est un peu `brouillon` mais il fonction et ce n'est qu'un exemple :)

Il n'y à pas de zip car il n'y à qu'un seul et unique petit fichier alors voilà ...

Source

  • #define WIN32_LEAN_AND_MEAN
  • #include <windows.h>
  • #include <stdlib.h>
  • #include <string.h>
  • #include <limits.h>
  • #include <stdio.h>
  • #include <assert.h>
  • #define MEGA_BIT (1024 * 1024) /* 1mb */
  • /* 64bits */
  • void MyCopyMemory( void * dst, const void * src, LONGLONG count )
  • {
  • register BYTE * d = (BYTE *) dst;
  • register BYTE * s = (BYTE *) src;
  • while ( count-- > 0 )
  • *d++ = *s++;
  • }
  • /* modifie la taille d'un fichier */
  • DWORD SetFileSize( void * pHandle, LONGLONG iSize )
  • {
  • /* ici on utilise un LARGE_INTEGER pour les fichiers de plus de 4go(plutôt rare mais bon) */
  • LARGE_INTEGER li;
  • DWORD error = NO_ERROR;
  • assert(pHandle != INVALID_HANDLE_VALUE);
  • assert(pHandle != NULL);
  • li.QuadPart = iSize;
  • /* modifie la position du curseur dans le fichier */
  • li.LowPart = SetFilePointer( pHandle, li.LowPart, &(li.HighPart), FILE_BEGIN );
  • if ( (li.LowPart != 0xffffffff) || (NO_ERROR == (error = GetLastError())) )
  • {
  • /* marque la fin du fichier la ou ce trouve le curseur */
  • if ( !SetEndOfFile( pHandle ) )
  • error = GetLastError();
  • }
  • return error;
  • }
  • /* retire X octet(s) dans un fichier */
  • DWORD RemoveData( void * pHandle, LONGLONG offset, LONGLONG count )
  • {
  • /* même chose ici avec le LARGE_INTEGER */
  • void * map;
  • void * ptr;
  • LARGE_INTEGER fs;
  • DWORD error = NO_ERROR;
  • assert(pHandle != INVALID_HANDLE_VALUE);
  • assert(pHandle != NULL);
  • /* récupère la taille du fichier */
  • fs.LowPart = GetFileSize( pHandle, &(fs.HighPart) );
  • if ( (fs.LowPart == 0xffffffff) && (NO_ERROR != (error = GetLastError())) )
  • return error;
  • /* si `offset` est plus grand que la taille du fichier, on quitte */
  • if ( offset > fs.QuadPart )
  • return ERROR_INVALID_PARAMETER;
  • /* ajuste le nombre d'octet à retirer(si besoin) */
  • if ( (offset + count) > fs.QuadPart )
  • count = (fs.QuadPart - offset);
  • /* création de la map */
  • map = CreateFileMapping(
  • pHandle,
  • NULL,
  • PAGE_READWRITE, /* accès en écriture obligatoire */
  • 0UL, /* on map tout alors 0 partout */
  • 0UL,
  • NULL
  • );
  • if ( NULL == map )
  • return GetLastError();
  • /* opération final */
  • ptr = MapViewOfFile(
  • map,
  • FILE_MAP_READ|FILE_MAP_WRITE, /* accès en écriture obligatoire */
  • 0UL, /* on map tout alors 0 partout */
  • 0UL,
  • 0UL
  • );
  • /******************************************************
  • *
  • `ptr` va contenir l'adresse de la map,
  • qui elle, ce trouve dans `l'address space`
  • du process.
  • Pour manipuler `ptr`, vaut mieux utiliser
  • une autre pointeur.
  • void * newptr = ptr;
  • *(BYTE *)newptr++ = 'y';
  • *(BYTE *)newptr++ = 'z';
  • etc ...
  • Si `ptr` est modifié(le pointeur et non
  • son contenue) alors il sera impossible de
  • libérer/fermer la map ...
  • C'est un peu comme une simple allocation
  • mémoire avec malloc()/free()
  • char * ptr = malloc( 50 * sizeof(char) );
  • ++ptr;
  • free( ptr ); // BOOM!!!
  • *
  • ******************************************************/
  • if ( NULL != ptr )
  • {
  • /* prévenir les `access violation` et compagnie */
  • __try
  • {
  • /* déplace les octets(cast/transtypage obligatoire) */
  • MyCopyMemory( (BYTE *)ptr + offset, (BYTE *)ptr + (offset + count), count );
  • }
  • __except ( EXCEPTION_EXECUTE_HANDLER )
  • {
  • /* Oups! Houston, nous avons un problème ici ... */
  • error = GetExceptionCode();
  • }
  • /*****************************************************
  • *
  • UnmapViewOfFile() flush les données lorsqu'elle
  • est appelé mais, d'après MSDN, il le fait
  • lentement/lâchement alors, un FlushViewOfFile()
  • à sa place ici, un peu plus rapide.
  • *
  • *****************************************************/
  • FlushViewOfFile( ptr, 0UL ); /* 0 car on flush tout */
  • UnmapViewOfFile( ptr ); /* décharge la map */
  • }
  • else
  • {
  • error = GetLastError();
  • }
  • /* ferme la map */
  • CloseHandle( map );
  • if ( NO_ERROR == error )
  • {
  • /* modifie la taille du fichier si aucune erreur */
  • /* taille du fichier moin les octets retirés */
  • return SetFileSize( pHandle, (fs.QuadPart - count) );
  • }
  • return error;
  • }
  • int main( int argc, char * argv[] )
  • {
  • void * hFile; /* handle du fichier */
  • char fname[] = ".\\testfile.txt"; /* nom du fichier à ouvrir/modifier */
  • /* ouverture/création du fichier */
  • hFile = CreateFile(
  • fname,
  • GENERIC_READ|GENERIC_WRITE, /* accès en écriture obligatoire */
  • 0UL, /* aucun partage */
  • NULL, /* aucun attribue de sécurité */
  • /*OPEN_EXISTING*/CREATE_ALWAYS, /* cré/remplace le fichier */
  • FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, /* attribus/flags */
  • NULL /* pas de template */
  • );
  • /* erreur? */
  • if ( hFile == INVALID_HANDLE_VALUE )
  • {
  • printf("CreateFile(): %lu\n", GetLastError());
  • return 0;
  • }
  • /* modifie la taille du fichier */
  • printf("SetFileSize(): %lu\n", SetFileSize( hFile, MEGA_BIT ));
  • /* retire les octets de 0+1tier jusqu'a 0+2tier */
  • /* on retire 1tier du fichier(le centre/millieu du fichier) */
  • printf("RemoveData(): %lu\n", RemoveData( hFile, (MEGA_BIT / 3), (MEGA_BIT / 3) ));
  • /* ferme le fichier */
  • CloseHandle( hFile );
  • putc( '\n', stdout );
  • return 0;
  • }
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <assert.h>

#define MEGA_BIT	(1024 * 1024)	/* 1mb */

/* 64bits */
void MyCopyMemory( void * dst, const void * src, LONGLONG count )
{
	register BYTE * d = (BYTE *) dst;
	register BYTE * s = (BYTE *) src;

	while ( count-- > 0 )
		*d++ = *s++;
}

/* modifie la taille d'un fichier */
DWORD SetFileSize( void * pHandle, LONGLONG iSize )
{

	/* ici on utilise un LARGE_INTEGER pour les fichiers de plus de 4go(plutôt rare mais bon) */
	LARGE_INTEGER li;
	DWORD error = NO_ERROR;

	assert(pHandle != INVALID_HANDLE_VALUE);
	assert(pHandle != NULL);

	li.QuadPart = iSize;

	/* modifie la position du curseur dans le fichier */
	li.LowPart = SetFilePointer( pHandle, li.LowPart, &(li.HighPart), FILE_BEGIN );

	if ( (li.LowPart != 0xffffffff) || (NO_ERROR == (error = GetLastError())) )
	{
		/* marque la fin du fichier la ou ce trouve le curseur */
		if ( !SetEndOfFile( pHandle ) )
			error = GetLastError();
	}

	return error;

}

/* retire X octet(s) dans un fichier */
DWORD RemoveData( void * pHandle, LONGLONG offset, LONGLONG count )
{

	/* même chose ici avec le LARGE_INTEGER */
	void * map;
	void * ptr;
	LARGE_INTEGER fs;
	DWORD error = NO_ERROR;

	assert(pHandle != INVALID_HANDLE_VALUE);
	assert(pHandle != NULL);

	/* récupère la taille du fichier */
	fs.LowPart = GetFileSize( pHandle, &(fs.HighPart) );

	if ( (fs.LowPart == 0xffffffff) && (NO_ERROR != (error = GetLastError())) )
		return error;

	/* si `offset` est plus grand que la taille du fichier, on quitte */
	if ( offset > fs.QuadPart )
		return ERROR_INVALID_PARAMETER;

	/* ajuste le nombre d'octet à retirer(si besoin) */
	if ( (offset + count) > fs.QuadPart )
		count = (fs.QuadPart - offset);

	/* création de la map */
	map = CreateFileMapping( 
							pHandle, 
							NULL, 
							PAGE_READWRITE, /* accès en écriture obligatoire */
							0UL, /* on map tout alors 0 partout */
							0UL, 
							NULL 
							);

	if ( NULL == map )
		return GetLastError();

	/* opération final */
	ptr = MapViewOfFile( 
						map, 
						FILE_MAP_READ|FILE_MAP_WRITE, /* accès en écriture obligatoire */
						0UL, /* on map tout alors 0 partout */
						0UL, 
						0UL 
						);

	/******************************************************
	 *
		`ptr` va contenir l'adresse de la map,
		qui elle, ce trouve dans `l'address space`
		du process.

		Pour manipuler `ptr`, vaut mieux utiliser
		une autre pointeur.

		void * newptr = ptr;

			*(BYTE *)newptr++ = 'y';
			*(BYTE *)newptr++ = 'z';
			etc ...

		Si `ptr` est modifié(le pointeur et non
		son contenue) alors il sera impossible de
		libérer/fermer la map ...

		C'est un peu comme une simple allocation
		mémoire avec malloc()/free()

		char * ptr = malloc( 50 * sizeof(char) );
		++ptr;
		free( ptr ); // BOOM!!!
	 *
	 ******************************************************/
	if ( NULL != ptr )
	{
		/* prévenir les `access violation` et compagnie */
		__try
		{
			/* déplace les octets(cast/transtypage obligatoire) */
			MyCopyMemory( (BYTE *)ptr + offset, (BYTE *)ptr + (offset + count), count );
		}
		__except ( EXCEPTION_EXECUTE_HANDLER )
		{
			/* Oups! Houston, nous avons un problème ici ... */
			error = GetExceptionCode();
		}
		/*****************************************************
		 *
			UnmapViewOfFile() flush les données lorsqu'elle
			est appelé mais, d'après MSDN, il le fait
			lentement/lâchement alors, un FlushViewOfFile()
			à sa place ici, un peu plus rapide.
		 *
		 *****************************************************/
		FlushViewOfFile( ptr, 0UL ); /* 0 car on flush tout */
		UnmapViewOfFile( ptr ); /* décharge la map */
	}
	else
	{
		error = GetLastError();
	}

	/* ferme la map */
	CloseHandle( map );

	if ( NO_ERROR == error )
	{
		/* modifie la taille du fichier si aucune erreur */
		/* taille du fichier moin les octets retirés */
		return SetFileSize( pHandle, (fs.QuadPart - count) );
	}

	return error;

}

int main( int argc, char * argv[] )
{

	void * hFile; /* handle du fichier */
	char fname[] = ".\\testfile.txt"; /* nom du fichier à ouvrir/modifier */

	/* ouverture/création du fichier */
	hFile = CreateFile( 
					fname, 
					GENERIC_READ|GENERIC_WRITE, /* accès en écriture obligatoire */
					0UL, /* aucun partage */
					NULL, /* aucun attribue de sécurité */
					/*OPEN_EXISTING*/CREATE_ALWAYS, /* cré/remplace le fichier */
					FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, /* attribus/flags */
					NULL /* pas de template */
					);

	/* erreur? */
	if ( hFile == INVALID_HANDLE_VALUE )
	{
		printf("CreateFile(): %lu\n", GetLastError());
		return 0;
	}

	/* modifie la taille du fichier */
	printf("SetFileSize(): %lu\n", SetFileSize( hFile, MEGA_BIT ));

	/* retire les octets de 0+1tier jusqu'a 0+2tier */
	/* on retire 1tier du fichier(le centre/millieu du fichier) */
	printf("RemoveData(): %lu\n", RemoveData( hFile, (MEGA_BIT / 3), (MEGA_BIT / 3) ));

	/* ferme le fichier */
	CloseHandle( hFile );
	putc( '\n', stdout );

	return 0;

}

Conclusion

Créé & testé sous Visual Studio 6/Windows 2000 Pro

Cet exemple démontre seulement comment `tronquer`
un fichier sans utiliser d'autres fichiers ou de tampons/buffers
temporaire, etc ... On ouvre le fichier, le modifie et le ferme, tout
simplement!




~(.:: NitRic ::.)~
18 mai 2007 01:44:37 :
ajout des mots clés( Vous aussi, mettez vos sources à jour !!! Ajoutez les mots clés !!! )
  • signaler à un administrateur
    Commentaire de angsthase le 04/04/2005 09:29:50

    Tout d'abord merci nitric d'avoir fait cette source !!

    Ensuite,  j'ai eux erreurs lors de la compil  :
         -  union large_integer has no member named low  part
         -  _ _________________________________high ___

    ???

  • signaler à un administrateur
    Commentaire de NitRic le 04/04/2005 10:09:15

    Okay, utilise ceci alors:

    typedef union _LargeInteger
    {
        struct
        {
            DWORD LowPart;
            LONG HighPart;
        };
        LONGLONG QuadPart;
    }LargeInteger;


    ensuite, remplace les `LARGE_INTEGER` par `LargeInteger`




    ~(.:: NitRic ::.)~

Ajouter un commentaire

Pub



Appels d'offres

Dessins techniques
Budget : 60€
Animation Flash - Doma...
Budget : 370€
Application flash medi...
Budget : 1 000€

CalendriCode

Juillet 2008
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Boutique

Boutique de goodies CodeS-SourceS