Csocket | Asynchronous TCP socket classes | Socket library

First, your code with ReadTCP function template is incorrect. SOCK_CLBK is a type of a function pointer that has an ellipsis at the end of its argument list, which is different from int (or any other type) that ReadTCP has. The compiler does not fail to compile because you explicitly convert the pointer to ReadTCP to SOCK_CLBK, but the call fails at runtime (you either receive a random value in the int a argument or crash).

Your second piece of code with std::bind is also wrong because std::bind returns a function object, not a pointer to function. The function object has operator(), so it can be called like a function, but it cannot be converted to a function pointer (for one, because the object also contains data, like the arguments you bound).

You must define a function that accepts a variable number of arguments (i.e. has an ellipsis at the end of its argument list) and pass that function as the callback. In that function, you can process the passed arguments and possibly invoke other specialized functions in your code, like ReadTCP.

Question 1: Your packet protocol doesn't fit with erlang's packet protocol, so I think you need to read from the socket in raw mode by specifying {packet, raw} or equivalently {packet, 0}, see https://erlang.org/doc/man/inet.html#packet.

I'm not sure how you are using handle_info() to read from the socket. Are you setting {active, true} so that data sent to the socket lands in the genserver's mailbox? If so, I don't think that will work because {active, true} tells erlang to automatically read N bytes from the socket, where N is specfied by {packet, N} when you open the socket. In your case, N will be 4. Erlang then uses the integer contained in those 4 bytes, let's call it MsLen, to read MsLen bytes from the socket. Erlang then combines all the chunks it reads from the socket into one complete message and places the complete message in the genserver's mailbox. However, your MsLen will be wrong because it's not an unsigned integer, rather it's an ascii encoded integer. Therefore, I think you need to open the socket in passive mode, {active, false}, read the first four bytes using gen_tcp:recv(), decode to get the integer length, then call gen_tcp:recv() again to read that many bytes from the socket.

Or, you could specify {active, true} and {packet, raw} so that any data sent to the socket will land in the genserver's mailbox. In that case, a message will consist of whatever size chunk happened to be sent to the socket by the underlying transport mechanism. So, you would need to use a loop around a receive block to keep extracting messages from the mail box until you got enough bytes for a complete message.

Question 2: When you open a socket in active mode, {active, true}, erlang automatically reads N number of bytes from the socket, where N is specified in {packet, N}, then erlang combines the chunks into a complete message and places the message in the process mailbox, which can only be read by a receive clause. Calling gen_tcp:recv() reads from the socket, which is of no help in that case. See details here: Erlang client-server example using gen_tcp is not receiving anything.

Specifying {active, once} tells erlang to open the socket with {active, true} for one message, then the socket switches to {active, false} or passive mode. In passive mode, a process needs to read directly from the socket by calling gen_tcp:recv(). You can specify {active, once} when you want to prevent a hostile actor from flooding the socket with millions of messages, which in turn would fill up the process mailbox and cause the process to crash. Will a hostile actor be able to flood the socket with millions of messages?

Question: 3 Synchronous with what? When you use ! to send a message to a genserver process, the message send is asynchronous because the process that sent the message does not wait for any type of response from the genserver process, so execution continues unabated in the sending process. With a genserver, we don't ask whether handle_call() is asynchronous, instead we ask whether the process that calls gen_server:call() is asynchronous with the genserver process. The process that calls gen_server:call() stops execution and waits for a response from the genserver process, so we say that the process that called gen_server:call() is synchronous with the genserver process.

Is a process that calls gen_tcp:send() asynchronous with the genserver process? gen_tcp:send() returns ok or an error message, so it does not wait for a reply from the genserver process, so a process that calls gen_tcp:send() is asynchronous with the genserver process.

Thanks for the clarification! Please see https://docs.oracle.com/javase/10/docs/api/java/io/ByteArrayOutputStream.html#write(byte%5B%5D,int,int)

The write method in ByteArrayOutputStream for byte[] needs two more arguments. Something like the following might work:

Your problem seems to not be try-catch but lack of error handling.

If we assume the commented-out code in sendMessage to be actually operational:

You must to allocate memory for buffer, because first parameter of fread:

Pointer to a block of memory with a size of at least (size*count) bytes, converted to a void*.

Use malloc or new.

I would recommend using std::array to not worry about deleting memory.

So I find a solution. I compress the image with numpy and io like this:

I solved this problem as my output will also come in the way I want.The basic idea of the solution is given below:-

You have some race conditions going on

Look at this:

Normally the recv() function does not guarantee to return the total amount of bytes you "request". The argument is just a maximum amount of bytes that you expect to receive, but the function can return less bytes than this if they are available in the buffer. Here it is an implementation from https://docs.python.org/3/howto/sockets.html