HTTP POST请求不会让我定义上下文类型

Question

I'm using Ubuntu 18.04 and boost.asio to send a POST request to a rest API. When the server is receiving the request it catches it but I can't seem to define its content type. I have a function collectRequestData that is supposed to parse the body of the request and return it where it is then saved to a MySQL database. When I print what the function returns it prints null when it should be the JSON text it was sent. When I print the "Content-Type" before the function is called it prints undefined when I think it should be "application/json" . My end goal here is when I run my client code by ./file.o localhost 8080 /licence '{JSON formatted text}' it connects to localhost port 8080 path /licence (which it does correctly) and then saves the JSON text to the MySQL database. Which it is not doing correctly and I'm pretty sure the cause is the "Content-Type" I'm new to working with servers and JavaScript so if anyone sees me doing something wrong please point it out. Also if you could give extra detail to help me understand a suggestion it would be much appreciated.

---

Below is my client code that sends the POST request

#include <iostream>
#include <istream>
#include <ostream>
#include <string>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;
using namespace std;

int main(int argc, char* argv[])
{
    cout << "main -start" << endl;
    try
    {
        boost::asio::io_service io_service;
        string ipAddress = argv[1]; //"localhost" for loop back or ip address otherwise, i.e.- www.boost.org;       
        string portNum = argv[2]; //"8000" for instance;
        string hostAddress;
        if (portNum.compare("80") != 0) // add the ":" only if the port number is not 80 (proprietary port number).
        {
            hostAddress = ipAddress + ":" + portNum;
        }
        else 
        { 
            hostAddress = ipAddress;
        }
        string wordToQuery = "";//this will be used for entry indexing
        string queryStr = argv[3]; //"/api/v1/similar?word=" + wordToQuery;
        string json = argv[4];

        // Get a list of endpoints corresponding to the server name.
        tcp::resolver resolver(io_service);
        tcp::resolver::query query(ipAddress, portNum);
        tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);

        // Try each endpoint until we successfully establish a connection.
        tcp::socket socket(io_service);
        boost::asio::connect(socket, endpoint_iterator);

        // Form the request. We specify the "Connection: close" header so that the
        // server will close the socket after transmitting the response. This will
        // allow us to treat all data up until the EOF as the content.
        string typeJSON = application/json;
        boost::asio::streambuf request;
        std::ostream request_stream(&request);
        request_stream << "POST " << queryStr << " HTTP/1.1\r\n";  // note that you can change it if you wish to HTTP/1.0
        request_stream << "Host: " << hostAddress << "\r\n";
        request_stream << "User-Agent: C/1.0";
        request_stream << "Content-Type: application/json; charset=utf-8\r\n";
        request_stream << "Accept: */*\r\n";
        request_stream << "Content-Length: " << json.length() << "\r\n"; 
        request_stream << "Connection: close\r\n\r\n";
        request_stream << json;

        // Send the request.
        boost::asio::write(socket, request);

        // Read the response status line. The response streambuf will automatically
        // grow to accommodate the entire line. The growth may be limited by passing
        // a maximum size to the streambuf constructor.
        boost::asio::streambuf response;
        boost::asio::read_until(socket, response, "\r\n");

        // Check that response is OK.
        std::istream response_stream(&response);
        std::string http_version;
        response_stream >> http_version;
        unsigned int status_code;
        response_stream >> status_code;
        std::string status_message;
        std::getline(response_stream, status_message);
        if (!response_stream || http_version.substr(0, 5) != "HTTP/")
        {
            std::cout << "Invalid response\n";
            return 1;
        }
        if (status_code != 200)
        {
            std::cout << "Response returned with status code " << status_code << "\n";
            return 1;
        }

        // Read the response headers, which are terminated by a blank line.
        boost::asio::read_until(socket, response, "\r\n\r\n");

        // Process the response headers.
        std::string header;
        while (std::getline(response_stream, header) && header != "\r")
        {
            std::cout << header << "\n";
        }

        std::cout << "\n";

        // Write whatever content we already have to output.
        if (response.size() > 0)
        {
            std::cout << &response;
        }

        // Read until EOF, writing data to output as we go.
        boost::system::error_code error;
        while (boost::asio::read(socket, response,boost::asio::transfer_at_least(1), error))
        {
            std::cout << &response;
        }

        if (error != boost::asio::error::eof)
        {
            throw boost::system::system_error(error);
        }
    }
    catch (std::exception& e)
    {
        std::cout << "Exception: " << e.what() << "\n";
    }

    return 0;
}

---

Below is the part of my server that handles the POST request

app.post('/licence', function (req, res) {
    collectRequestData(req, result => {
        //console.log(request.headers['Content-Type']);
        console.log(result);
        sleep(5000);
        connection.query('INSERT INTO licence SET ?', result, function (error, results) {
            if (error) throw error;
            res.end(JSON.stringify(results));
        });
        //res.end(`Parsed data belonging to ${result.fname}`);
    });
});

function collectRequestData(request, callback) {
    console.log(request.headers['Content-Type']);
    const FORM_URLENCODED = 'application/json';
    if(request.headers['Content-Type'] === FORM_URLENCODED) {
        let body = '';
        request.on('data', chunk => {
            body += chunk.toString();
        });
        request.on('end', () => {
            callback(JSON.parse(body));
        });
    }
    else {
        callback(null);
    }
}

Answer 1

You are missing an end of line

request_stream << "User-Agent: C/1.0";

should be

request_stream << "User-Agent: C/1.0\r\n";

Means your content type header never gets recognised because it isn't on a separate line

Answer 2

It feels a web-server issue, you are probably not compliant with the http protocol specification. Try using boost::beast, available in boost 1.66 and over. It's a wrapper over boost::asio that adds high level web-server and web-socket functionality. You don't need to bother with low-level HTTP implementation.

sample code

Answer 3

I'm assuming you're using nodeJS for the server

nodejs gives you the request header in lower case

so

function collectRequestData(request, callback) {
    console.log(request.headers['content-type']);
    const FORM_URLENCODED = 'application/json';
    if(request.headers['content-type'] === FORM_URLENCODED) {
        let body = '';

once you fix the other issue identified by @john, of course

ie

You are missing an end of line

request_stream << "User-Agent: C/1.0";

should be

request_stream << "User-Agent: C/1.0\\r\\n";

Answer 4

First of all, i think you should double check whether the server is right or not. Offering one method:

curl "http://localhost:8080/licence" --data "{json format text}" -v

If this command responses the same result as yours, it is the problem of server. If not, try to assemble the same request package content in your code as the curl, especially "\\r\\n" and so on.

Answer 5

The correct solution is a combination of what @john and @Jaromanda X said and I also had to change const FORM_URLENCODED = 'application/json'; to const FORM_URLENCODED = 'application/json; charset=utf-8' const FORM_URLENCODED = 'application/json; charset=utf-8'