Forum Ubuntu-it

Mi trovo dal lato client, il quale apre un file esistente, comunica la grandezza del file al server, alloca lo spazio per la lettura del file e con fprinf leggo il file inserendolo nell'array appena allocato per poi mandarlo al server.
Il mio problema è che la fprintf mi legge dal file solo la prima stringa del file e stop.
Per trasferire file tra client e server, bisogna ogni volta allocare un buffer sia dal lato client che dal lato server per inviare e ricevere il file?

Codice: Seleziona tutto

  /*   Lettura File     */
  fp = fopen(argv[1], "r"); 
  if(fp==NULL) error("ERROR opening file");

  printf("LUNGHEZZA DEL FILE \n");
  fseek(fp, 0, SEEK_END);
  l = ftell(fp);
  char buffer[20];
  sprintf(len, "%d",l);
  printf("LEN = %s\n",len);
  send(sockfd, len, 19, 0);
  rewind(fp);

  sendBuff = (char *)malloc(sizeof(char)*l);
  if(sendBuff == NULL) error("malloc");

 /* send file  */
  fscanf(fp,"%s",sendBuff);
  printf("%s\n",sendBuff);

  write(sockfd, sendBuff, strlen(sendBuff));

  fclose(fp);
  close(sockfd);

Il mio problema è che la fprintf mi legge dal file solo la prima stringa del file e stop.

Non sono a casa e non ho tutte i miei esempi, e non sono così bravo da sapere tutto a memoria
ma fprintf non legge, ma stampa su stream.
Per leggere potresti usare fgets() se non erro
La mia impressione è che stai mettendo un po' troppa carnina

al fuoco.
Conviene fare prove separate sulle varie funzioni fprintf,strcat...e via dicendo, poi assemblare tutto

EDIT

ma hai cambiato il titolo? diceva fprintf e ora fscanf

Ho sbagliato il titolo è fscanf.
Si ho provato anche:

Codice: Seleziona tutto

 while(fgets(sendBuff, l , fp)!=NULL);
 printf("%s",sendBuff);

ma c'è qualche problema che non capisco mi stampa la stringa vuota.

Eh scusa penso di dovermi prendere un pò di pausa tra un pò -.-

prova a togliere il ; dopo il while, secondo se vuoi leggere un carattere alla volta c e fgetc o fread ma non fgets che legge una riga fino a \n o al max n caratteri.
Ripeto devi studiare un pò di piu

L'ho risolto leggendo carattere per carattere con fgetc.

Codice: Seleziona tutto

/* send file  */

  int ch, i=0;
  while(1)
    {
      ch=fgetc(fp);
      if(feof(fp))break;
      *(sendBuff+i)=ch;
      i++;
    }
  n = send(sockfd, sendBuff, l, 0);
  if(n<0) error("send");
  fclose(fp);
  close(sockfd);
  exit(0);

Concordo.

invii solo il primo carattere? quanto è grande sendBuff? perchè non hai scritto:

Codice: Seleziona tutto

   int ch, i=0;
   char sendBuff[1024];
    int n,nr;
   ...
   nr = fread(sendBuff,1,1024,fp);
  n = send(sockfd, sendBuff, nr, 0);
  if(n != nr)  error("send");
  fclose(fp);
  close(sockfd);
  exit(0);

se vai in easyframework->easysocket hai tanto da divertirti

Codice: Seleziona tutto

n = send(sockfd, sendBuff, l, 0);  //l non 1

Da ieri il tuo framework è diventata la mia Bibbia, la mia linfa informatica. Con fread e fwrite è possibile trasmettere qualsiasi tipo di file?
Mi consigli qualche libro?
Comunque in tutto questo volevo fare comunicare due processi nella rete.
Il server crea un file vuoto e ci copia quello che manda il client.

---SERVER---

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>

#define BACKLOG 5

void error(char *msg)
{
  perror(msg);
  exit(1);
}

int main(int argc, char *argv[])
{ 
  FILE *fp;
  int sockfd, new_fd, port, n;
  char *nameBuff;
  char *recvBuff;
  char *path;
  struct sockaddr_in serv_addr, clin_addr;
  
  if(argc<2)
    {
      fprintf(stderr,"MANCA: numero porta, nome file\n");
      exit(1);
    }

  if(argc<3)
    {
      fprintf(stderr,"MANCA: nome file\n");
      exit(1);
    }
 
  port=atoi(argv[1]);
  nameBuff=argv[2];

  /* New File Empty   */
  path = getenv("HOME");
  strcat(path, "/Desktop/");
  strcat(path, nameBuff);

  //printf("PATH = %s",path);
  fp=fopen(path, "wb");
  if(fp<0) error("file");

  /*      Socket        */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if(sockfd < 0) error("socket");

  /*   Inizializzazione struct socket  */
  bzero(&serv_addr, sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(port);


  /*    Bind     */
  int b;
  b=bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
  if(b<0) error("bind");

  
  /*   Listen    */
  int l;
  l=listen(sockfd, BACKLOG);
  if(l<0) error("listen");

  int sin_size;
  sin_size = sizeof(clin_addr);

  printf("SERVER ATTIVO\n");
  
  /*   Accept   */
  int flag = 1;
  while(flag)
    {
  new_fd = accept(sockfd, (struct sockaddr *)&clin_addr , &sin_size);
  if(new_fd<0) error("accept");

  printf("HOST: %d connesso\n",new_fd);



  /*   recv len file  */
  char len[20];
  read(new_fd, len, 19 ); 
  printf("LEN = %s\n", len);
  recvBuff = (char *)malloc(sizeof(char)*atoi(len));
  if(recvBuff == NULL) error("malloc");
  
  //fprintf(fp,"%c",new_fd);
  
  int rec;
  int ar[atoi(len)];
  printf("RICEZIONE FILE...\n");

   rec = read(new_fd ,ar, 19);
   if(rec<0) error("read");
   
   rec = fwrite(ar,1,19,fp);
   if(rec<0) error("write");

  fclose(fp);

  close(new_fd);
  flag=1;
    }

  close(sockfd);
  exit(0);
}

---CLIENT---

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>


void error(char *msg)
{
  perror(msg);
  exit(1);
}


int main(int argc, char *argv[])
{ 
  FILE *fp;
  int sockfd,port, n;
  struct hostent *server;
  struct sockaddr_in clin_addr;
  char *sendBuff;

  if(argc<2)
    {
      fprintf(stderr,"MANCA: nome file, indirizzo IP, numero porta\n");
      exit(1);
    }

  if(argc<3)
    {
      fprintf(stderr,"MANCA: indirizzo IP, numero porta\n");
      exit(1);
    }

  if(argc<4)
    {
      fprintf(stderr,"MANCA: numero porta\n");
      exit(1);
    }

  port=atoi(argv[3]);

  /*    Socket    */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if(sockfd<0) error("socket");


  /*  Controllo server   */
  server = gethostbyname(argv[2]);
  if(server == NULL) error("ERROR opening server");


  /* inizializzazione struct socket  */
  bzero((char *)&clin_addr, sizeof(clin_addr));
   bcopy((char *)server->h_addr, (char *)&clin_addr.sin_addr.s_addr,server->h_length);
  clin_addr.sin_family = AF_INET;
  clin_addr.sin_port = htons(port);
  

  /*   Connessione   */
  int c;
  c = connect(sockfd, (struct sockaddr *)&clin_addr, sizeof(clin_addr));
  if(c<0) error("connect");

  
  /* Invio File  */
  char len[20];
  int l;
  
  /*   Lettura File     */
  fp = fopen(argv[1], "rb"); 
  if(fp==NULL) error("ERROR opening file");

  fseek(fp, 0, SEEK_END);
  l = ftell(fp);
  
  char buffer[20];
  sprintf(len, "%d",l);
  send(sockfd, len, 19, 0);
  rewind(fp);

  sendBuff = (char *)calloc(l,sizeof(char));
  if(sendBuff == NULL)error("malloc");

 /* send file  */
  int ar[l];
  int ch, i=0;

  n = fread(ar,1,l,fp);
  if(n<0) error("fread");

  /* while(1) */
  /*   { */
  /*     ch=fgetc(fp); */
  /*     if(feof(fp))break; */
  /*     *(sendBuff+i)=ch; */
  /*     i++; */
  /*   } */

  n = send(sockfd, ar, l, 0);
  if(n<0) error("send");


  fclose(fp);
  close(sockfd);
  exit(0);
}

libro per?
con fread/fwrite leggi/scrivi da file non trasmetti niente!
Puoi leggere qualsiasi tipo di cosa come vuoi tu, è la funzione dello STD più a basso livello.

mi fa piacere che il framework sia utile

sul mio phone l e 1 sono simili e in piccolo a volte si fatica, potresti leggeri Obfuscate C and other mistery, uno della famosa raccolta di MAW

culr.h è un header che devo scaricare per il framework?

Leggo un file da client(fread) e lo spedisco sulla socket del server (send/write), dal server quando lo leggo(read/recv), metto prima tutto in un buffer di int, per poi scrivere(fwrite) la copia del file, indipendentemente dal tipo di file.

Bella raccolta e anche bel forum che non conoscevo.

Con fread e fwrite è possibile trasmettere qualsiasi tipo di file?

Io ribadisco la mia teoria: approfondisci separatamente le varie "istruzioni". Quando le hai capite bene (ma tanto ci tornerai su
più volte come tutti, perchè capirai che un tal aspetto lo avevi frainteso o non capito bene) e poi fai programmi più complicati.
fread e fwrite leggono e scrivono. Li puoi usare per leggere un file (fread) e per scrivere fwrite.
Oltretutto c'è l'aspetto della lettura e scrittura binaria, altro capitolo ancora, e non è così scontata la cosa.
Molto utile per esempio per copiare file non testuali es mp3 o bmp.
Usa l'easy di Vb, ma esercitati anche con singole funzioni
PS: sono un neofita anche io, quindi...dico quello che secondo me (ripeto secondo me) è la strada giusta

Se t'interessa fwrite/fread binaria e un po' di ragionamenti:
http://forum.ubuntu-it.org/viewtopic.php?f=33&t=595232

Per le socket e capire la rete in generale ho letto "Keith W. Ross James F. Kurose - Reti di calcolatori e internet. Un approccio top-down",
per il C C-[Kernighan - Ritchie] e Linux for Programmers and Users li sto leggendo da un mese e qualche giorno.
L'unico modo per imparare a programmare è programmando almeno penso. Poi non mi sembra che voglia fare una cosa complessissima, anzi mi sento una super schiappa che un ragazzetto di 13 anni nella silicon valley già la faceva ai tempi dell'asilo.
In effetti ho dimostrato un pò di superficialità , ma meglio altrimenti non avrei scoperto il Bigt di vb

.
Comunque ti ringrazio

Comunque ci so riuscito a copiare qualsiasi file senza socket, adesso mi basta conciliare le due cose.

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void error(char *msg)
{
  perror(msg);
  exit(1);
}

int main()
{
  FILE *fd, *fc;
  int len, r, w;
  int *buf;

  /* apro file da copiare */
  fd = fopen("Mars4_5.jar","rb");
  if(fd<0) error("apertura file");

  /* apro file per la copia  */
  fc = fopen("copia","wb");
  if(fc<0) error("creazione copia");

  /* len file */
  fseek(fd,0,SEEK_END);
  len = ftell(fd);
  rewind(fd);

  buf=(int *)malloc(sizeof(int)*len);
  r = fread(buf,1,len,fd);

  w = fwrite(buf,1,len,fc);

  if(r!=w)error("errore copia");
  exit(0);

}

devi scaricare le libcurl-dev quindi libreria+header.
Serve anche la pthread.
Ho iniziato a scrivere anche tutta la documentazione in italiano, ho momentaneamente interrotto perché sto creando un modulo per linux che proprio oggi ho finito.Devo testarlo e poi mi rimetto al lavoro sul framework e devo rimuove un brutto bug alla EasyGCC, ma in testa ho già un altro progetto che spinge....non ho tempo....
Se durante il tuo studio del c crei funzioni che non sono presenti nel framework puoi inserirle, è aperto a tutti.

Programma, studia e programma, divertiti!

BIGT = Bash Inotify GoogleTranslate, nato da una richiesta di un utente sul forum.

Ma è un file di testo o un file generico?
generalmente non si alloca tutto lo spazio necessario a contenere il file ma un buffer più piccolo e lo si usa per trasferire i dati, puoi vedere l'esempio in easyframework->easyfile->efile.c->ino_cpy()

Si è un file generico. Avevo provato a scrivere due funzioni una che scrive un file ad una socket e l'altro che legge un file da una socket, prendendo spunto dall metodo ino_cpy(CHAR* d, CHAR* s) in efile.c. Il file mi arriva della stessa dimensione ma corrotto.

Ho installato il framework. Per utilizzarlo basta che importo l'header che mi interessa??

Codice: Seleziona tutto

SIZE_BUFF è 2**20
/* scrive il file f sulla socket sockfd */
int f_transfert_sock(char *f, int sockfd)
{
  FILE *fs;
  int szf, rszf, wr;
  char len[125];
  char buffer[SIZE_BUF];
  struct stat b;

  fs = fopen(f,"rb");
  if(fs==NULL) return 0;
  
  if(stat(f,&b)==-1) return 0;
  szf=b.st_size;

  snprintf(len,125,"%d",szf);
  wr = write(sockfd,len,125);
  if(wr<0) return 0;
  
  while(szf)
    {
      if(szf<=SIZE_BUF)
	{
	  szf = fread(buffer,1,szf,fs);
	  wr = write(sockfd,buffer,szf);
	  if(wr!=szf) return 0;
	  szf = 0;
	}
      else
	{
	  rszf = fread(buffer,1,SIZE_BUF,fs);
	  wr = write(sockfd,buffer,rszf);
	  if(wr!=rszf) return 0;
	  szf-=rszf;
	}
    }
     fclose(fs);
     return 0; 
}

Codice: Seleziona tutto

/* legge dalla sockfd un file di dimensione sz e lo copia nel file f */
int f_recv_sock(char *f, int sockfd, int sz)
{
  FILE *fd;
  int szf, rszf, wr , w, ret;
  char buffer[SIZE_BUF];

  fd = fopen(f,"wb");
  if(fd==NULL) return -1;
 
  while(sz)
    {
	if(sz<=SIZE_BUF)
	{
		w = read(sockfd, buffer, sz,);
		ret = fwrite(buffer,1,w,fd);
		if(ret!=w) error("copia inconsistente");
		sz=0;
	}
	else{
      		wr = read(sockfd, buffer, SIZE_BUF);
		ret = fwrite(buffer, 1, wr, fd);
		if(ret!=wr) error("copia inconsistente");
		sz-=wr;
	}      
    }
	fclose(fd);
	printf("FILE RICEVUTO\n");
	return 0;
}

Vai qui:
http://forum.ubuntu-it.org/viewtopic.ph ... 2&start=20
salta le prime pagine se hai installato correttamente.
Poi Vb spiega come fare. In breve dal tuo main passi gli argomenti per quella funzione.
Adesso, non so cosa ti serve....mi sono perso

Hai problemi con cosa?

Si grazie c'è scritto proprio tutto.
Sempre il solito: mandare un file generico da client a server. I file di testo li manda bene, ma se provo con un pdf mi arriva corrotto nonostante sia della stessa dimensione.

Ho capito il problema mi inserisce qualche dato in più all'inizio.
þHello World!!
Il primo byte mi arriva corrotto e alla fine ne perdo uno.

I file di testo li manda bene, ma se provo con un pdf mi arriva corrotto nonostante sia della stessa dimensione.

Un pdf lo devi mandare in modalità binaria idem un mp3, bmp ecc..

Ho utilizzato la modalità di lettura e scrittura 'rb' e 'wb'. Per la lettura e scrittura del file nel buffer ho utilizzato 'fread' e 'fwrite' ma per leggerlo e scriverlo dal e sul fd della socket ho usato 'read' e 'write'

Forum Ubuntu-it

[C] problema fscanf

[C] problema fscanf

Re: [C] problema fprintf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf

Re: [C] problema fscanf