sending mpz_t over tcp network

[Veress Krisztián]

Dear gmp users,

I would like to send an alone mpz_t integer over tcp/ip from a server
towards a client, but on the client side I'm always reading 1 bytes,
when I'm sending 15 bytes on the server side.(I get these numbers from
recv and send.)
Could anyone tell me where I am wrong in the C code below, or an
alternate solution? 
I probed to convert mpz_t to string, and send this one, but the same.

Here is my code, and thanks:

server.c:

#include <sys/socket.h>
#include <netdb.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <gmp.h>

int read_from_client (int filedes, mpz_t *adat);
int main(int argc, char* argv[0])
{
  /* input ellenőrzés */
  if(argc != 3)
  {
     printf("Használat: %s <port> <max_clients>\n",argv[0]);
     return 0;
  }
  if( atoi(argv[1]) < 1025 || atoi(argv[1]) > 65535)
  {
    printf("A port nem megfelelő! (1025 - 65535)\n");
    return 0;
  }
  if( atoi(argv[2]) > 65535 || atoi(argv[2]) < 2)
  {
    printf("A kliensek száma nem megfelelő! (2 - 65535)\n");
    return 0;
  }
  unsigned short int port = atoi(argv[1]);
  unsigned short int max_clients = atoi(argv[2]);
  

  /* szerver beállítása */
  struct sockaddr_in server;  
  memset(&server, 0, sizeof(server));
  server.sin_family = AF_INET;
  server.sin_port = htons(port);  
  server.sin_addr.s_addr = INADDR_ANY;

  
  /* szerver indítása */
  int server_fd = 0;
  if (( server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
  {      
    perror("Nincs elég erőforrás a szerver számára!\n");
    return 0;
  }  
  if(bind(server_fd, (struct sockaddr*)&server, sizeof(struct sockaddr))
== -1)
  { 
    perror("Nem tudtam elindítani a szervert!\n");
    return 0;
  }
  if(listen(server_fd, max_clients) < 0)
  {
    perror("Nem tudtam elindítani a szervert!\n");
    return 0;
  }
  int i = 0;
  int dtablesize = getdtablesize();

  /*
   * SZERVER KÉSZ
   */  

  /* van 1 db socketünk, amelyen kapcsolatra várunk */
  fd_set rfd;
  fd_set c_rfd;
  FD_ZERO(&rfd);
  FD_SET(server_fd, &rfd);

  struct sockaddr_in clients;
  socklen_t sin_size = sizeof(struct sockaddr_in);
  int rc=0, new_conn_fd=0;

  /* olvasó buffer */
  
  mpz_t k;
  mpz_init_set_ui(k,(unsigned long)341891823);
  printf("size: %d\n",mpz_size(k));
  /* accept-write-close végtelen ciklusba lépünk */  
  while (1)
  {
    
    c_rfd = rfd;
    rc = select(dtablesize, &c_rfd, NULL, NULL, NULL);    

    /* új kapcsolódási kísérlet! */
    if (FD_ISSET(server_fd, &c_rfd)) 
    {
      if( (new_conn_fd = accept(server_fd, (struct sockaddr *)&clients,
&sin_size)) != -1)
      {
	rc = send(new_conn_fd, &k, mpz_size(k), 0);
	gmp_printf("Küldés : %Zd - %d bytes\n",k,rc);
	FD_SET(new_conn_fd,&rfd);
	continue;
      }
    }    
    /* esetleg valamilyen kommunikáció a kliensektől? */
    for (i=0; i<dtablesize; i++)
    {
      if (i != server_fd && FD_ISSET(i, &c_rfd))
      {
	/* adat olvasása a klienstől */
	rc = read_from_client(i,&k);
	
	/* ha a kliens bontotta a kapcsolatot */
	if ( rc < 0 )
	{
	  printf("Egy node lekapcsolódott a szerverről!\n");
	  close(i);
	  FD_CLR(i, &rfd);
    	}
	/* ha az olvasás helyesen megtörtént */
        else
	{
	  continue;
	}
      }
    }
  }/*while*/
  mpz_clear(k);
}

int read_from_client (int filedes, mpz_t* adat)
{
  int nbytes;
  nbytes = read (filedes, adat, mpz_size(*adat));
  if (nbytes < 0)
  {
    /* Olvasási hiba */
    perror ("Olvasási hiba!");
    exit (EXIT_FAILURE);
  }
  else if (nbytes == 0)
  {
    /* Kapcsolatot bontja a kliens */
    return -1;
  }
  return nbytes;
}




client.c:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <gmp.h>
int read_from_server (int filedes, mpz_t *adat);

int main(int argc, char *argv[])
{
  if (argc != 3) 
  {       
    printf("Használat : %s <IP cím> <port>\n", argv[0]);
    return 0;
  }
  if( atoi(argv[2]) < 1025 || atoi(argv[2]) > 65535)
  {
    printf("A port nem megfelelő! (1025 - 65535)\n");
    return 0;
  }
  unsigned short int port = atoi(argv[2]);
  int client_fd;
  struct hostent *he;
  struct sockaddr_in server;
  if ( (he = gethostbyname(argv[1])) == NULL )
  {
    perror("A szervert nem találom, valószínűleg nem elérhető!\n");
    return 0;
  }
  if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  {
    perror("Nincs elég erőforrás a program számára!\n");
    return 0;
  }
  memset(&server, 0, sizeof(server));
  server.sin_family = AF_INET;
  server.sin_port = htons(port);
  server.sin_addr = *((struct in_addr *)he->h_addr);
  /* kapcsolódás a szerverhez */
  if(connect(client_fd, (struct sockaddr *)&server, sizeof(struct
sockaddr)) == -1)
  {
    perror("Nem tudtam csatlakozni a szerverhez.\n");
    return 0;
  }
  printf("A kapcsolat létrejött a szerverrel : %s:%d.\n\n",
(char*)inet_ntoa(server.sin_addr), ntohs(server.sin_port));

  mpz_t k;
  mpz_init(k);
  int rc;
  /* addig olvasunk, amíg 0-t nem ad vissza a read_from_server, azaz a
szerver bontotta a kapcsolatot */
  while ((rc=read_from_server(client_fd, &k)))
  {
    gmp_printf("Olvasva: %Zd - %d bytes\n",k,rc);
    break;
    /* itt megkapjuk a részfeladatot, kiszámoljuk, visszaküldjük*/
  }
  mpz_clear(k);
  
  printf("Kilépek...\n");
  shutdown(client_fd, 2);
  return 0;
}

int read_from_server (int filedes, mpz_t* adat)
{
  int nbytes;
  nbytes = read(filedes, adat, mpz_size(*adat));
  if (nbytes < 0)
  {
    /* Olvasási hiba */
    perror ("Olvasási hiba!");
    exit (EXIT_FAILURE);
  }
  else if (nbytes == 0)
  {
    /* Kapcsolatot bontja a szerver */
    return 0;
  }
  else
  {
    /* Helyes olvasás */
    return 1;
  }
}