Ejemplo simple de C de hacer un HTTP POST y consumir la respuesta

90

Me gustaría crear una aplicación C muy simple que haga una publicación HTTP. Se necesitarán algunos parámetros y los utilizará para construir una URL. Solo me gustaría hacer un HTTP POST simple y obtener la respuesta sin el uso de curl (las bibliotecas no están ni se instalarán en la máquina que necesita para ejecutarse).

Pseudocódigo:

  1. Procesar 2 argumentos

  2. Coloque argumentos en la URL de la plantilla: http://api.somesite.com/apikey=ARG1&command=ARG2

  3. Publicar en la URL generada

  4. Consumir respuesta

Mis búsquedas en Google y SO no han arrojado nada sobre este asunto.

c  http  http-post 
— kmarks2
fuente
2
¿Utiliza algún tipo de marco de red? ¿Qué sistema operativo usas?
— cnicutar
Será solo una caja básica de Fedora o Cent. Los marcos de red son los habituales sys / socket, netdb, arpa / inet. Simplemente no libcurl.
— kmarks2
1
No libcurl. ¿Está dispuesto a ir con cualquier otra biblioteca o tiene que ser todo POSIX?
— cnicutar
Todo POSIX lamentablemente. Tiene que ser completamente independiente en cualquier sistema.
— kmarks2
2
Tengo una muestra que hice para usted, pero no entiendo por qué está usando POST si no hay un cuerpo para el mensaje. Si todos los parámetros están en la cadena de consulta, ¿por qué no quiere hacer un GET?
— Jerry Jeremiah

Respuestas:

191

Un mensaje tiene una parte de encabezado y un cuerpo del mensaje separados por una línea en blanco. La línea en blanco SIEMPRE es necesaria incluso si no hay cuerpo del mensaje. El encabezado comienza con un comando y tiene líneas adicionales de pares clave-valor separados por dos puntos y un espacio. Si hay un cuerpo de mensaje, puede ser cualquier cosa que desee.

Las líneas en el encabezado y la línea en blanco al final del encabezado deben terminar con un retorno carraige y un par de salto de línea (ver estilo de salto de línea del encabezado HTTP ), por eso esas líneas tienen \ r \ n al final.

Una URL tiene la forma de http://host:port/path?query_string

Hay dos formas principales de enviar una solicitud a un sitio web:

  • GET: la cadena de consulta es opcional pero, si se especifica, debe ser razonablemente corta. Debido a esto, el encabezado podría ser solo el comando GET y nada más. Un mensaje de muestra podría ser:

    GET /path?query_string HTTP/1.0\r\n
\r\n

  • POST: Lo que normalmente estaría en la cadena de consulta está en el cuerpo del mensaje. Debido a esto, el encabezado debe incluir los atributos Content-Type: y Content-Length: así como el comando POST. Un mensaje de muestra podría ser:

    POST /path HTTP/1.0\r\n
Content-Type: text/plain\r\n
Content-Length: 12\r\n
\r\n
query_string

Entonces, para responder a su pregunta: si la URL en la que está interesado en PUBLICAR es http://api.somesite.com/apikey=ARG1&command=ARG2, entonces no hay cuerpo o cadena de consulta y, en consecuencia, no hay razón para PUBLICAR porque no no es nada para poner en el cuerpo del mensaje y, por lo tanto, nada para poner en Content-Type: y Content-Length:

Supongo que podrías PUBLICAR si realmente quisieras. En ese caso, su mensaje se vería así:

POST /apikey=ARG1&command=ARG2 HTTP/1.0\r\n
\r\n

Entonces, para enviar el mensaje, el programa C necesita:

  • crear un enchufe
  • buscar la dirección IP
  • abre el enchufe
  • enviar la solicitud
  • espera la respuesta
  • cerrar el enchufe

Las llamadas de envío y recepción no enviarán / recibirán necesariamente TODOS los datos que les proporcione; devolverán la cantidad de bytes realmente enviados / recibidos. Depende de usted llamarlos en un bucle y enviar / recibir el resto del mensaje.

Lo que no hice en esta muestra es ningún tipo de verificación de errores reales: cuando algo falla, simplemente salgo del programa. Déjame saber si te funciona:

#include <stdio.h> /* printf, sprintf */
#include <stdlib.h> /* exit */
#include <unistd.h> /* read, write, close */
#include <string.h> /* memcpy, memset */
#include <sys/socket.h> /* socket, connect */
#include <netinet/in.h> /* struct sockaddr_in, struct sockaddr */
#include <netdb.h> /* struct hostent, gethostbyname */

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

int main(int argc,char *argv[])
{
    /* first what are we going to send and where are we going to send it? */
    int portno =        80;
    char *host =        "api.somesite.com";
    char *message_fmt = "POST /apikey=%s&command=%s HTTP/1.0\r\n\r\n";

    struct hostent *server;
    struct sockaddr_in serv_addr;
    int sockfd, bytes, sent, received, total;
    char message[1024],response[4096];

    if (argc < 3) { puts("Parameters: <apikey> <command>"); exit(0); }

    /* fill in the parameters */
    sprintf(message,message_fmt,argv[1],argv[2]);
    printf("Request:\n%s\n",message);

    /* create the socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) error("ERROR opening socket");

    /* lookup the ip address */
    server = gethostbyname(host);
    if (server == NULL) error("ERROR, no such host");

    /* fill in the structure */
    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(portno);
    memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);

    /* connect the socket */
    if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
        error("ERROR connecting");

    /* send the request */
    total = strlen(message);
    sent = 0;
    do {
        bytes = write(sockfd,message+sent,total-sent);
        if (bytes < 0)
            error("ERROR writing message to socket");
        if (bytes == 0)
            break;
        sent+=bytes;
    } while (sent < total);

    /* receive the response */
    memset(response,0,sizeof(response));
    total = sizeof(response)-1;
    received = 0;
    do {
        bytes = read(sockfd,response+received,total-received);
        if (bytes < 0)
            error("ERROR reading response from socket");
        if (bytes == 0)
            break;
        received+=bytes;
    } while (received < total);

    if (received == total)
        error("ERROR storing complete response from socket");

    /* close the socket */
    close(sockfd);

    /* process response */
    printf("Response:\n%s\n",response);

    return 0;
}

Como se señaló en la otra respuesta, 4096 bytes no es una respuesta muy grande. Elegí ese número al azar asumiendo que la respuesta a su solicitud sería breve. Si puede ser grande, tiene dos opciones:

  • lea el encabezado Content-Length: de la respuesta y luego asigne dinámicamente suficiente memoria para contener la respuesta completa.
  • escribir la respuesta en un archivo a medida que llegan las piezas

Información adicional para responder a la pregunta formulada en los comentarios:

¿Qué sucede si desea PUBLICAR datos en el cuerpo del mensaje? Luego, debe incluir los encabezados Content-Type: y Content-Length :. La longitud del contenido: es la longitud real de todo después de la línea en blanco que separa el encabezado del cuerpo.

Aquí hay una muestra que toma los siguientes argumentos de línea de comando:

  • anfitrión
  • Puerto
  • comando (GET o POST)
  • ruta (sin incluir los datos de la consulta)
  • datos de consulta (poner en la cadena de consulta para GET y en el cuerpo para POST)
  • lista de encabezados (Content-Length: es automático si se usa POST)

Entonces, para la pregunta original, ejecutaría:

a.out api.somesite.com 80 GET "/apikey=ARG1&command=ARG2"

Y para la pregunta formulada en los comentarios, ejecutaría:

a.out api.somesite.com 80 POST / "name=ARG1&value=ARG2" "Content-Type: application/x-www-form-urlencoded"

Aquí está el código:

#include <stdio.h> /* printf, sprintf */
#include <stdlib.h> /* exit, atoi, malloc, free */
#include <unistd.h> /* read, write, close */
#include <string.h> /* memcpy, memset */
#include <sys/socket.h> /* socket, connect */
#include <netinet/in.h> /* struct sockaddr_in, struct sockaddr */
#include <netdb.h> /* struct hostent, gethostbyname */

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

int main(int argc,char *argv[])
{
    int i;

    /* first where are we going to send it? */
    int portno = atoi(argv[2])>0?atoi(argv[2]):80;
    char *host = strlen(argv[1])>0?argv[1]:"localhost";

    struct hostent *server;
    struct sockaddr_in serv_addr;
    int sockfd, bytes, sent, received, total, message_size;
    char *message, response[4096];

    if (argc < 5) { puts("Parameters: <host> <port> <method> <path> [<data> [<headers>]]"); exit(0); }

    /* How big is the message? */
    message_size=0;
    if(!strcmp(argv[3],"GET"))
    {
        message_size+=strlen("%s %s%s%s HTTP/1.0\r\n");        /* method         */
        message_size+=strlen(argv[3]);                         /* path           */
        message_size+=strlen(argv[4]);                         /* headers        */
        if(argc>5)
            message_size+=strlen(argv[5]);                     /* query string   */
        for(i=6;i<argc;i++)                                    /* headers        */
            message_size+=strlen(argv[i])+strlen("\r\n");
        message_size+=strlen("\r\n");                          /* blank line     */
    }
    else
    {
        message_size+=strlen("%s %s HTTP/1.0\r\n");
        message_size+=strlen(argv[3]);                         /* method         */
        message_size+=strlen(argv[4]);                         /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            message_size+=strlen(argv[i])+strlen("\r\n");
        if(argc>5)
            message_size+=strlen("Content-Length: %d\r\n")+10; /* content length */
        message_size+=strlen("\r\n");                          /* blank line     */
        if(argc>5)
            message_size+=strlen(argv[5]);                     /* body           */
    }

    /* allocate space for the message */
    message=malloc(message_size);

    /* fill in the parameters */
    if(!strcmp(argv[3],"GET"))
    {
        if(argc>5)
            sprintf(message,"%s %s%s%s HTTP/1.0\r\n",
                strlen(argv[3])>0?argv[3]:"GET",               /* method         */
                strlen(argv[4])>0?argv[4]:"/",                 /* path           */
                strlen(argv[5])>0?"?":"",                      /* ?              */
                strlen(argv[5])>0?argv[5]:"");                 /* query string   */
        else
            sprintf(message,"%s %s HTTP/1.0\r\n",
                strlen(argv[3])>0?argv[3]:"GET",               /* method         */
                strlen(argv[4])>0?argv[4]:"/");                /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            {strcat(message,argv[i]);strcat(message,"\r\n");}
        strcat(message,"\r\n");                                /* blank line     */
    }
    else
    {
        sprintf(message,"%s %s HTTP/1.0\r\n",
            strlen(argv[3])>0?argv[3]:"POST",                  /* method         */
            strlen(argv[4])>0?argv[4]:"/");                    /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            {strcat(message,argv[i]);strcat(message,"\r\n");}
        if(argc>5)
            sprintf(message+strlen(message),"Content-Length: %d\r\n",strlen(argv[5]));
        strcat(message,"\r\n");                                /* blank line     */
        if(argc>5)
            strcat(message,argv[5]);                           /* body           */
    }

    /* What are we going to send? */
    printf("Request:\n%s\n",message);

    /* create the socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) error("ERROR opening socket");

    /* lookup the ip address */
    server = gethostbyname(host);
    if (server == NULL) error("ERROR, no such host");

    /* fill in the structure */
    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(portno);
    memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);

    /* connect the socket */
    if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
        error("ERROR connecting");

    /* send the request */
    total = strlen(message);
    sent = 0;
    do {
        bytes = write(sockfd,message+sent,total-sent);
        if (bytes < 0)
            error("ERROR writing message to socket");
        if (bytes == 0)
            break;
        sent+=bytes;
    } while (sent < total);

    /* receive the response */
    memset(response,0,sizeof(response));
    total = sizeof(response)-1;
    received = 0;
    do {
        bytes = read(sockfd,response+received,total-received);
        if (bytes < 0)
            error("ERROR reading response from socket");
        if (bytes == 0)
            break;
        received+=bytes;
    } while (received < total);

    if (received == total)
        error("ERROR storing complete response from socket");

    /* close the socket */
    close(sockfd);

    /* process response */
    printf("Response:\n%s\n",response);

    free(message);
    return 0;
}
— Jerry Jeremías
fuente
¿Qué argumentos deben pasarse cuando se llama?
— Santiago Martí Olbrich
Debe pasar algo que se usará como apikey como primer parámetro y algo en el segundo parámetro que se usará como comando. Si desea utilizar una cadena de consulta completamente diferente, debe cambiar la cadena de formato, el número de parámetros y el mensaje de uso.
— Jerry Jeremiah
2
Este código emite una solicitud HTTP con formato incorrecto. HTTP especifica que las líneas de solicitud deben terminar con pares de retorno de carro / avance de línea ( \r\n), pero este código utiliza avances de línea desnudos.
— John Bollinger
@JohnBollinger Eso es muy cierto. Gracias por mencionarlo. Con suerte, la respuesta editada es mejor.
— Jerry Jeremiah
¿Qué pasa con este mensaje de publicación? "POST /variableName=%s&value=%s HTTP/1.1\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 4\r\n\r\n\r\n"Quiero publicar como name = reaz. Responde 400 solicitudes
— incorrectas
12

La respuesta de Jerry es genial. Sin embargo, no maneja grandes respuestas. Un simple cambio para manejar esto:

memset(response, 0, sizeof(response));
total = sizeof(response)-1;
received = 0;
do {
    printf("RESPONSE: %s\n", response);
    // HANDLE RESPONSE CHUCK HERE BY, FOR EXAMPLE, SAVING TO A FILE.
    memset(response, 0, sizeof(response));
    bytes = recv(sockfd, response, 1024, 0);
    if (bytes < 0)
        printf("ERROR reading response from socket");
    if (bytes == 0)
        break;
    received+=bytes;
} while (1);
— Peter Washington
fuente
3
Podrías agrandar la matriz de respuesta en mi ejemplo. Supuse que estaba recuperando algo de json y no estaba descargando un archivo enorme pero, por supuesto, incluso json puede ser megabytes dependiendo de la consulta ...
— Jerry Jeremiah
1
Soy un principiante en C y tu respuesta puede ser correcta. Pero, ¿puede agregar una explicación a su respuesta?
— boop
2
En realidad, esto es solo un comentario sobre la respuesta aceptada y no debería haberse hecho como un intento de respuesta por separado.
— Michael Gaskill
1
Solo una cosa para agregar aquí, esto funciona muy bien, sin embargo, debería leer el tamaño del búfer: 1 bytes. Y para verlo correctamente, no usaría una nueva línea en esa declaración impresa. Debería verse así:bytes = recv(sockfd, response, 1023, 0)
— xjsc16x
11

Después de semanas de investigación. Se me ocurrió el siguiente código. Creo que esto es lo mínimo necesario para establecer una conexión segura con SSL a un servidor web.

#include <stdio.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/bio.h>

#define APIKEY "YOUR_API_KEY"
#define HOST "YOUR_WEB_SERVER_URI"
#define PORT "443"

int main() {

    //
    //  Initialize the variables
    //
    BIO* bio;
    SSL* ssl;
    SSL_CTX* ctx;

    //
    //   Registers the SSL/TLS ciphers and digests.
    //
    //   Basically start the security layer.
    //
    SSL_library_init();

    //
    //  Creates a new SSL_CTX object as a framework to establish TLS/SSL
    //  or DTLS enabled connections
    //
    ctx = SSL_CTX_new(SSLv23_client_method());

    //
    //  -> Error check
    //
    if (ctx == NULL)
    {
        printf("Ctx is null\n");
    }

    //
    //   Creates a new BIO chain consisting of an SSL BIO
    //
    bio = BIO_new_ssl_connect(ctx);

    //
    //  Use the variable from the beginning of the file to create a 
    //  string that contains the URL to the site that you want to connect
    //  to while also specifying the port.
    //
    BIO_set_conn_hostname(bio, HOST ":" PORT);

    //
    //   Attempts to connect the supplied BIO
    //
    if(BIO_do_connect(bio) <= 0)
    {
        printf("Failed connection\n");
        return 1;
    }
    else
    {
        printf("Connected\n");
    }

    //
    //  The bare minimum to make a HTTP request.
    //
    char* write_buf = "POST / HTTP/1.1\r\n"
                      "Host: " HOST "\r\n"
                      "Authorization: Basic " APIKEY "\r\n"
                      "Connection: close\r\n"
                      "\r\n";

    //
    //   Attempts to write len bytes from buf to BIO
    //
    if(BIO_write(bio, write_buf, strlen(write_buf)) <= 0)
    {
        //
        //  Handle failed writes here
        //
        if(!BIO_should_retry(bio))
        {
            // Not worth implementing, but worth knowing.
        }

        //
        //  -> Let us know about the failed writes
        //
        printf("Failed write\n");
    }

    //
    //  Variables used to read the response from the server
    //
    int size;
    char buf[1024];

    //
    //  Read the response message
    //
    for(;;)
    {
        //
        //  Get chunks of the response 1023 at the time.
        //
        size = BIO_read(bio, buf, 1023);

        //
        //  If no more data, then exit the loop
        //
        if(size <= 0)
        {
            break;
        }

        //
        //  Terminate the string with a 0, to let know C when the string 
        //  ends.
        //
        buf[size] = 0;

        //
        //  ->  Print out the response
        //
        printf("%s", buf);
    }

    //
    //  Clean after ourselves
    //
    BIO_free_all(bio);
    SSL_CTX_free(ctx);

    return 0;
}

El código anterior explicará en detalle cómo establecer una conexión TLS con un servidor remoto.

Nota IMPORTANTE : este código no verifica si la clave pública fue firmada por una autoridad válida. Lo que significa que no uso certificados raíz para la validación. No olvide implementar esta verificación; de lo contrario, no sabrá si está conectando el sitio web correcto

Cuando se trata de la solicitud en sí. No es nada más que escribir la solicitud HTTP a mano.

También puede encontrar en este enlace una explicación de cómo instalar openSSL en su sistema y cómo compilar el código para que use la biblioteca segura .

— David Gatti
fuente
2
¡Buena explicación!
— Satyam Koyani
no, la siguiente variable es el puerto, ya nos estamos conectando al puerto correcto.
— David Gatti
3

Mango agregado.
Encabezado de host agregado.
Añadido soporte linux / windows, probado (XP, WIN7).
ADVERTENCIA: ERROR: "error de segmentación" si no hay host, ruta o puerto como argumento.

#include <stdio.h> /* printf, sprintf */
#include <stdlib.h> /* exit, atoi, malloc, free */
#include <unistd.h> /* read, write, close */
#include <string.h> /* memcpy, memset */
#ifdef __linux__ 
    #include <sys/socket.h> /* socket, connect */
    #include <netdb.h> /* struct hostent, gethostbyname */
    #include <netinet/in.h> /* struct sockaddr_in, struct sockaddr */
#elif _WIN32
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <windows.h>
    #pragma comment(lib,"ws2_32.lib") //Winsock Library

#else

#endif

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

int main(int argc,char *argv[])
{

    int i;
    struct hostent *server;
    struct sockaddr_in serv_addr;
    int bytes, sent, received, total, message_size;
    char *message, response[4096];
    int portno = atoi(argv[2])>0?atoi(argv[2]):80;
    char *host = strlen(argv[1])>0?argv[1]:"localhost";
    char *path = strlen(argv[4])>0?argv[4]:"/";
    if (argc < 5) { puts("Parameters: <host> <port> <method> <path> [<data> [<headers>]]"); exit(0); }
    /* How big is the message? */
    message_size=0;
    if(!strcmp(argv[3],"GET"))
    {
                printf("Process 1\n");
        message_size+=strlen("%s %s%s%s HTTP/1.0\r\nHost: %s\r\n");        /* method         */
        message_size+=strlen(argv[3]);                         /* path           */
        message_size+=strlen(path);                         /* headers        */
        if(argc>5)
            message_size+=strlen(argv[5]);                     /* query string   */
        for(i=6;i<argc;i++)                                    /* headers        */
            message_size+=strlen(argv[i])+strlen("\r\n");
        message_size+=strlen("\r\n");                          /* blank line     */
    }
    else
    {
                printf("Process 2\n");
        message_size+=strlen("%s %s HTTP/1.0\r\nHost: %s\r\n");
        message_size+=strlen(argv[3]);                         /* method         */
        message_size+=strlen(path);                            /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            message_size+=strlen(argv[i])+strlen("\r\n");
        if(argc>5)
            message_size+=strlen("Content-Length: %d\r\n")+10; /* content length */
        message_size+=strlen("\r\n");                          /* blank line     */
        if(argc>5)
            message_size+=strlen(argv[5]);                     /* body           */
    }
            printf("Allocating...\n");
    /* allocate space for the message */
    message=malloc(message_size);

    /* fill in the parameters */
    if(!strcmp(argv[3],"GET"))
    {
        if(argc>5)
            sprintf(message,"%s %s%s%s HTTP/1.0\r\nHost: %s\r\n",
                strlen(argv[3])>0?argv[3]:"GET",               /* method         */
                path,                                          /* path           */
                strlen(argv[5])>0?"?":"",                      /* ?              */
                strlen(argv[5])>0?argv[5]:"",host);            /* query string   */
        else
            sprintf(message,"%s %s HTTP/1.0\r\nHost: %s\r\n",
                strlen(argv[3])>0?argv[3]:"GET",               /* method         */
                path,host);                                    /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            {strcat(message,argv[i]);strcat(message,"\r\n");}
        strcat(message,"\r\n");                                /* blank line     */
    }
    else
    {
        sprintf(message,"%s %s HTTP/1.0\r\nHost: %s\r\n",
            strlen(argv[3])>0?argv[3]:"POST",                  /* method         */
            path,host);                                        /* path           */
        for(i=6;i<argc;i++)                                    /* headers        */
            {strcat(message,argv[i]);strcat(message,"\r\n");}
        if(argc>5)
            sprintf(message+strlen(message),"Content-Length: %d\r\n",(int)strlen(argv[5]));
        strcat(message,"\r\n");                                /* blank line     */
        if(argc>5)
            strcat(message,argv[5]);                           /* body           */
    }
    printf("Processed\n");
    /* What are we going to send? */
    printf("Request:\n%s\n",message);
        /* lookup the ip address */

    total = strlen(message);
    /* create the socket */
    #ifdef _WIN32
WSADATA wsa;
SOCKET s;

printf("\nInitialising Winsock...");
if (WSAStartup(MAKEWORD(2,2),&wsa) != 0)
{
    printf("Failed. Error Code : %d",WSAGetLastError());
    return 1;
}

printf("Initialised.\n");

//Create a socket
if((s = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET)
{
    printf("Could not create socket : %d" , WSAGetLastError());
}

printf("Socket created.\n");

server = gethostbyname(host);
serv_addr.sin_addr.s_addr = inet_addr(server->h_addr);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(portno);
memset(&serv_addr,0,sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(portno);
memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
//Connect to remote server
if (connect(s , (struct sockaddr *)&serv_addr , sizeof(serv_addr)) < 0)
{
    printf("connect failed with error code : %d" , WSAGetLastError());
    return 1;
}

puts("Connected");
if( send(s , message , strlen(message) , 0) < 0)
{
    printf("Send failed with error code : %d" , WSAGetLastError());
    return 1;
}
puts("Data Send\n");

//Receive a reply from the server
if((received = recv(s , response , 2000 , 0)) == SOCKET_ERROR)
{
    printf("recv failed with error code : %d" , WSAGetLastError());
}

puts("Reply received\n");

//Add a NULL terminating character to make it a proper string before printing
response[received] = '\0';
puts(response);

closesocket(s);
WSACleanup();
    #endif
    #ifdef __linux__ 
    int sockfd;
    server = gethostbyname(host);
    if (server == NULL) error("ERROR, no such host");
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0) error("ERROR opening socket");
        /* fill in the structure */
        memset(&serv_addr,0,sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(portno);
        memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
                /* connect the socket */
        if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
            error("ERROR connecting");
                /* send the request */

    sent = 0;
    do {
        bytes = write(sockfd,message+sent,total-sent);
        if (bytes < 0)
            error("ERROR writing message to socket");
        if (bytes == 0)
            break;
        sent+=bytes;
    } while (sent < total);
    /* receive the response */
    memset(response, 0, sizeof(response));
    total = sizeof(response)-1;
    received = 0;
    printf("Response: \n");
    do {
       printf("%s", response);
       memset(response, 0, sizeof(response));
       bytes = recv(sockfd, response, 1024, 0);
        if (bytes < 0)
           printf("ERROR reading response from socket");
       if (bytes == 0)
           break;
       received+=bytes;
    } while (1);

    if (received == total)
        error("ERROR storing complete response from socket");

    /* close the socket */
    close(sockfd);
    #endif


    free(message);

    return 0;
}
— William Desportes
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.