TRONQUER UN FICHIER(C - WINDOWS) tronquer, fichier, windows, win32, mapping, Source N°30502

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

Auteur : NitRic

Site perso

Ecrire un message privé

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 ::.)~

Historique

18 mai 2007 01:44:37 :: ajout des mots clés( Vous aussi, mettez vos sources à jour !!! Ajoutez les mots clés !!! )

Sources du même auteur

Toutes les sources de NitRic

Sources de la même categorie

Toutes les sources de la catégorie API

Sources en rapport avec celle ci

Commentaires

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 ___

???
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 ::.)~