[C] Scrittura di testo in file genera un file vuoto

[Alhazred]

Sto scrivendo un'applicazione client-server che fa uso di mailslot, il processo client passa una stringa al server e questo deve scrivere tale stringa su un file.
Ho questo problema, il server crea il file su cui scrivere, ma il file resta vuoto.
La stringa viene passata correttamente, tant'è che se al processo server la faccio stampare sulla console non ho problemi... perché questa stringa non la scrive sul file?
Ecco il codice del server:

#include <windows.h>
#include <stdio.h>

#define ErroreIO               -1

int main(int argc,char **argv)
{
	HANDLE        handle;
	LPCTSTR       errMsg, FileDaScrivere = "output.txt";
        FILE          *uscita;


	/* Crea il mailslot */
	handle = CreateMailslot("\\\\.\\mailslot\\blort",
					0,
					MAILSLOT_WAIT_FOREVER,
					NULL);
	if (handle == INVALID_HANDLE_VALUE) 
	{
		TCHAR	strError[256];

		errMsg = "CreateMailslot ha fallito: %s";
print_err:
		// Prende il messaggio d'errore da Windows associato al numero d'errore
		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(),
                                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                      &strError[0], 256, 0);

		// Visualizza l'errore
		printf(errMsg, &strError[0]);

		// Chiude i mailslot aperti
		if (handle != INVALID_HANDLE_VALUE) CloseHandle(handle);

		return(-1);
	}

	while(1)
	{
		DWORD	msgSize;
		BOOL	err;

        uscita = fopen(FileDaScrivere,"w");
        if(uscita == NULL)
            return ErroreIO;


		/* Prende la dimensione del prossimo record */
		err = GetMailslotInfo(handle, 0, &msgSize, 0, 0);

		/* Controlla se c'è un errore */
		if (!err)
		{
			errMsg = "GetMailslotInfo failed: %s";
			goto print_err;
		}
			
		/* Controllo se msgSize è nullo */
		if (msgSize != (DWORD)MAILSLOT_NO_MESSAGE)
		{
			void *	buffer;

			/* Allocazione di memoria */
			buffer = GlobalAlloc(GMEM_FIXED, msgSize);
			if (!buffer) printf("Errore allocazione del blocco di memoria!");
			else
			{
				DWORD	numRead;

				/* legge il record */
				err = ReadFile(handle, buffer, msgSize, &numRead, 0);

				/* Controlla se c'è un errore */
				if (!err) printf("ReadFile error: %d", GetLastError());

				/* Mi assicuro di aver letto tutti i bytes */
				else if (msgSize != numRead)
                                      printf("ReadFile non ha letto il giusto numero di bytes!");

				else
				{
                                     /***********************************
                                      ***********************************
                                      Qui sotto le stampe su console e su file
                                     ***********************************
                                     ***********************************/

                                     // bufer contiene la stringa
                                     printf(buffer); //scrive sulla console il cont. di buffer
                                     pririntf(uscita,buffer); //non scrive sul file
				}

				/* Libero il buffer */
				GlobalFree(buffer);
			}
		}

		/* pausa */
		Sleep(1000);
	}

	return(0);
}

[MItaly]

pririntf(uscita,buffer); //non scrive sul file

pririntf? fprintf, semmai...
Tra l'altro alla fine non chiudi il file, forse è per quello che non viene scritto niente (se non chiudi il file o non richiami la fflush può darsi che il buffer non venga scritto su disco).

[Alhazred]

Si, pririntf... è venuto fuori mentre sistemavo la formattazione del codice da mettere qui, ovviamente è fprintf.

Comunque niente da fare, ho provato sia la chiusura del file che la fflush.

[Vincenzo1968]

Ciao Alhazred,

il secondo parametro di fprintf deve contenere la stringa di controllo:

fprintf(uscita, "%s", (char*)buffer); //così dovrebbe scrivere sul file

[Alhazred]

Non va neanche così.
Comunque la fprintf funziona anche con soli due parametri, l'ho testata su un codice di prova che ho usato prima di questo per verificare la scrittura su file.

[shodan]

Il problema è qui:

	while(1)
	{
		DWORD	msgSize;
		BOOL	err;

        uscita = fopen(FileDaScrivere,"w");

a ogni iterazione del ciclo resetti il file.

[Vincenzo1968]

Originariamente inviato da Alhazred
Non va neanche così.
Comunque la fprintf funziona anche con soli due parametri, l'ho testata su un codice di prova che ho usato prima di questo per verificare la scrittura su file.

Si, hai ragione, la printf funziona anche senza specificare la stringa di controllo.
Prova a sostituire il parametro per l'apertura del file, cosi:

uscita = fopen(FileDaScrivere,"a+");

Con "a+" il file viene creato se non esiste ( e se invece esiste, non viene distrutto ma il cursore viene posizionato alla fine del file per l'aggiunta di nuovi dati ).

Con "w" se il file esiste, il suo contenuto viene distrutto.

Fammi sapere.

[Samuele_70]

Se leggi i dati dal file con la ReadFile(), per scriverli devi usare la WriteFile().

fprintf(uscita, "%s", (char*)buffer); //così dovrebbe scrivere sul file

Anche così la fprintf() potrebbe non essere la funzione più indicata, in quanto tratterebbe 'buffer'
come una normale stringa null-terminated.

[Vincenzo1968]

Ho fatto una prova creando un client per la mailslot:

Client:

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>

int _tmain(int argc, _TCHAR* argv[])
{
	LPSTR lpszMessage = "Messaggio di prova per MailSlot."; 
	BOOL fResult; 
	HANDLE hFile; 
	DWORD cbWritten; 
 
	hFile = CreateFile("\\\\.\\mailslot\\blort", 
		GENERIC_WRITE, 
		FILE_SHARE_READ,  // required to write to a mailslot 
		(LPSECURITY_ATTRIBUTES) NULL, 
		OPEN_EXISTING, 
		FILE_ATTRIBUTE_NORMAL, 
		(HANDLE) NULL); 
 
	if (hFile == INVALID_HANDLE_VALUE) 
	{ 
		printf("\s\n", "Errore nell'apertura della MailSlot");
		return FALSE; 
	} 
 
	fResult = WriteFile(hFile, 
		lpszMessage, 
		(DWORD) lstrlen(lpszMessage) + 1,  // include terminating null 
		&cbWritten, 
		(LPOVERLAPPED) NULL); 
 
	if (!fResult) 
	{ 
		printf("\s\n", "Errore nell'invio del Messaggio");
		return FALSE; 
	} 

	printf("\s\n", "Messaggio inviato!");

	fResult = CloseHandle(hFile); 
 
	if (!fResult) 
	{ 
		printf("\s\n", "Errore nella chiusura del file");
		return FALSE; 
	} 
 
	return 0;
}

Server:

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>


int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE		handle;
	LPCTSTR		errMsg;
	FILE		*uscita;
	char		FileDaScrivere[255] = "output.txt";

	/* Crea il mailslot */
	handle = CreateMailslot("\\\\.\\mailslot\\blort",
					0,
					MAILSLOT_WAIT_FOREVER,
					NULL);
	if (handle == INVALID_HANDLE_VALUE) 
	{
		TCHAR	strError[256];

		errMsg = "CreateMailslot ha fallito: %s";
print_err:
		// Prende il messaggio d'errore da Windows associato al numero d'errore
		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(),
                                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                      &strError[0], 256, 0);

		// Visualizza l'errore
		printf(errMsg, &strError[0]);

		// Chiude i mailslot aperti
		if (handle != INVALID_HANDLE_VALUE)
			CloseHandle(handle);

		return(-1);
	}

	while(1)
	{
		DWORD	msgSize;
		BOOL	err;

        //uscita = fopen(FileDaScrivere, "w");
        uscita = fopen(FileDaScrivere, "a+");

        if(uscita == NULL)
            return -1;


		/* Prende la dimensione del prossimo record */
		err = GetMailslotInfo(handle, 0, &msgSize, 0, 0);

		/* Controlla se c'è un errore */
		if (!err)
		{
			errMsg = "GetMailslotInfo failed: %s";
			goto print_err;
		}
			
		/* Controllo se msgSize è nullo */
		if (msgSize != (DWORD)MAILSLOT_NO_MESSAGE)
		{
			void *	buffer;

			/* Allocazione di memoria */
			buffer = GlobalAlloc(GMEM_FIXED, msgSize);
			if (!buffer)
				printf("Errore allocazione del blocco di memoria!");
			else
			{
				DWORD	numRead;

				/* legge il record */
				err = ReadFile(handle, buffer, msgSize, &numRead, NULL);

				/* Controlla se c'è un errore */
				if (!err)
					printf("ReadFile error: %d", GetLastError());
				/* Mi assicuro di aver letto tutti i bytes */
				else if (msgSize != numRead)
					printf("ReadFile non ha letto il giusto numero di bytes!");
				else
				{
					/***********************************
					***********************************
					Qui sotto le stampe su console e su file
					***********************************
					***********************************/

					// buffer contiene la stringa
					printf("%s\n", (char*)buffer); //scrive sulla console il cont. di buffer
					fprintf(uscita, "%s\n", (char*)buffer); //non scrive sul file
				}

				/* Libero il buffer */
				GlobalFree(buffer);
				fclose(uscita);
			}
		}

		/* pausa */
		Sleep(1000);
	}

	return 0;
}

Cosi funziona. Il problema stava proprio nell'apertura del file con l'opzione "w" ( che ad ogni ciclo svuota il file, al contrario di "a+" che aggiunge i messaggi alla fine del file ).

[Alhazred]

Si, con a+ funziona, grazie a tutti