TRONQUER UN FICHIER(C - WINDOWS)

#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;

}