Tronquer un fichier(c - windows)

Commenter

Contenu du snippet

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 / Exemple : 


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

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (NitRic)