Hola, estoy cursando la materia de redes en mi escuela, y el profesor es de esos que llegan y dicen lo que vas a hacer todo e semestre y no lo vuelve a ver hasta el final. En fin , hasta ahora eh podido con todos los programas, en este estoy mas que atascado, el problema es el siguiente:

Realizar una calculadora con sockets. El cliente envia 2 numeros enteros de 2 bytes cada uno mas el simbolo de la operacion (+, - , / , *) de 1 byte, el mensaje tendria que ser asi "35003500-" . De este lado hay cosas que no entiendo, a que se refiere con un entero de 2 bytes, segun yo es -32k hasta 32k aprox pero entonces como puedo delimitar eso y a como entro y envio la informacion, el buffer debe ser char o que tipo de dato.
Mientras que el cliente recibe la cadena, la interpreta y regresa la operacion como 1 entero de 4 bytes, ahi de nuevo con los bytes

Si alguno puede ayudarme con el code o con algo estaria mas que agradecido, estoy en mi ultimo chance de pasar la materia o me cargo el año ): Hoy por mi mañana por ustedes xc

 Cliente.cpp

// IP y puerto fijos; envia y recibe un mensaje
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include<iostream>
using namespace std;
//#define PORT 8080
#define PORT 8888


int main(int argc, char const *argv[])
{
   int sock = 0, valread;
   struct sockaddr_in serv_addr;
   //char *hello = "Hello from client 1";
    char A[1024],B[1024],sign[1024]; //2 bytes 1 byte
   char buffer[1024] = {0};
   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
   {
      printf("\n Socket creation error \n");
      return -1;
   }

   serv_addr.sin_family = AF_INET;
   serv_addr.sin_port = htons(PORT);
   
   // Convert IPv4 and IPv6 addresses from text to binary form
   if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)
   {
      printf("\nInvalid address/ Address not supported \n");
      return -1;
   }

   if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
   {
      printf("\nConnection Failed \n");
      return -1;
   }

    cout<<"Entero A:"<<endl;
    cin>>A;
    cout<<"Entero B:"<<endl;
    cin>>B;
    cout<<"Signo:"<<endl;
    cin>>sign;

    //cast bitwise
   send(sock , A , 1024 , 0 );
    send(sock , B , 1024 , 0 );
    send(sock, sign , 1024 , 0);
   printf("Numbers sent!\n");

   //valread = read( sock , buffer, 1024);
   //printf("%s\n",buffer );
   return 0;
}

    Servidor.cpp

// Server side C/C++ program to demonstrate Socket programming
// El servidor recibe y luego envia un mensaje

#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include<iostream>
using namespace std;
#define PORT 8888

//Caracteristicas: puerto fijo TCP
int main(int argc, char const *argv[])
{
   int server_fd, new_socket, valread;
   struct sockaddr_in address;
   int opt = 1;
   int addrlen = sizeof(address);
   char buffer[1024] = {0};
   
   // Creating socket file descriptor
   if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
   {
      perror("socket failed");
      exit(EXIT_FAILURE);
   }
   
   // Forcefully attaching socket to the port 8080
   if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,
                                    &opt, sizeof(opt)))
   {
      perror("setsockopt");
      exit(EXIT_FAILURE);
   }
   address.sin_family = AF_INET;
   address.sin_addr.s_addr = INADDR_ANY;
   address.sin_port = htons( PORT );
   
   // Forcefully attaching socket to the port 8080
   if (bind(server_fd, (struct sockaddr *)&address,
                        sizeof(address))<0)
   {
      perror("bind failed");
      exit(EXIT_FAILURE);
   }
   if (listen(server_fd, 3) < 0)
   {
      perror("listen");
      exit(EXIT_FAILURE);
   }

    if ((new_socket = accept(server_fd, (struct sockaddr *)&address,
               (socklen_t*)&addrlen))<0)
   {
      perror("accept");
      exit(EXIT_FAILURE);
   }


    while(1){
       
   valread = read( new_socket , buffer, 1024 );
   printf("%s\n",buffer );

   //send(new_socket , hello , strlen(hello) , 0 );
   //printf("Hello message sent\n");

    }


   
   return 0;
}

Como te están especificando que deben ser enteros de 2 bytes, entonces supongo que te piden que envíes los datos, no como una cadena ASCII (pues en ese caso cada entero podría ocupar hasta 6 bytes, incluyendo el signo positivo/negativo) sino como valores binarios, por lo que no deberías leerlos como cadenas, sino como enteros. Así que, para empezar, A y B deberían ser de tipo int16_t, como ya te dijeron. Y no tiene ningún sentido que sign sea un array de 1024 caracteres; debería ser un simple char.

La forma más simple es enviar (y recibir) una variable a la vez. Esto no es muy eficiente ni correcto, pero te puede sacar del apuro.

En el cliente, una vez que el usuario introdujo los números y el signo, haz algo así:

// Conviertes de orden de bytes local a red
A = htons(A);
B = htons(B);
 
send(sock , &A , sizeof(A) , 0 );
send(sock , &B , sizeof(B) , 0 );
send(sock, &sign , sizeof(sign) , 0);
 
int32_t total;
read( sock , &total, sizeof(total));
 
// Conviertes de orden de bytes de red a local
total = ntohl(total);
std::cout <<  "El total es: " << total << "\n";

En el servidor:

// Pesimos nombres de variables, pero por consistencia con tu codigo, los dejo asi
int16_t A, B;
char sign;
int32_t total;
read( new_socket , &A, sizeof(A) );
A = ntohs(A);
// ...y lo mismo para B y sign...

 Y con un switch/case verificas sign. Por ejemplo:

...
case '+':
	total = A + B;
break;
case '-':
	total = A - B;
break;
// etc.

Y finalmente:

total = htonl(total);
send(new_socket , &total, sizeof(total) , 0 );

Esto, como te dije, no es ni mucho menos ideal. Dado que estás enviando cantidades diminutas de bytes, puedes dar por hecho que va a funcionar sin problemas, pero en general, sería más eficiente juntar las variables en un bloque de bytes (ojo, no cadena de texto sino bytes) y enviar/recibir eso. Y lo correcto sería verificar que los datos se envíen/reciban completos. Las funciones read y send no necesariamente envian/reciben el número de bytes que les indiques, por lo que podría ser necesario leer o enviar los restantes con llamadas sucesivas. El problema es que, viendo que buena parte de tu código simplemente la copiaste de algún lugar, y que tienes cosas inexplicables, como lo de la variable sign que te comenté al inicio, creo que la forma más correcta se te podría complicar. De cualquier manera, te doy algunas sugerencias por si lo quisieras intentar.

Dado que vas a enviar 5 bytes fijos, podrías hacer algo así en el cliente:

// Como NO es una cadena, no necesita caracter nulo al final
char buffer[5];
/* Igual podriamos redondear a 8 chars, pues las potencias de 2 siempre son mucho mas agradables :) */ 

Y copiar ahí los valores de A, B (luego de haberlos convertido con htons) y sign. Para esto podrías usar memcpy, u operaciones a nivel de bits, como &, >> (si ya estás en programación de sockets, supongo que ya conocerás el funcionamiento de memcpy al menos).

Luego envias ese buffer.

Las funciones send y read devuelven el número de bytes leídos/enviados, así que puedes tener una variable que lleve la cuenta de los bytes que faltan de enviar/leer. Aquí va un pseudocódigo con una forma típica de enviar buffers completos:

int restantes = TOTAL_A_ENVIAR;
while (restantes > 0) {
	int enviados = send(bytes_restantes_del_buffer);
	/* verificar el valor de enviados: si es igual a 0 o -1, algo salio mal. Lidiar con el error 	*/
	// En caso contrario
	restantes -= enviados;
}

Lo mismo al recibir datos con read. Una vez leído el buffer, se copian sus 2 primeros bytes a A, y los dos siguientes a B (de nuevo, se puede hacer con memcpy), y  luego las conviertes a representación local con ntohs. En el caso de sign, dado que es un char, directamente le podrías asignar el valor de buffer[4].