Chapter 57, Unix Domain Sockets

Read chapter 57
But also man 7 unix
The address structure
- ```
struct sockaddr_un {
   sa_family_t sun_family;               /* AF_UNIX */
   char        sun_path[108];            /* Pathname */
}; 
```
- The sun is for socket unix
- Our author warns us that the 108 is variable for implementation so don't count on it.
- Use sizeof(sockaddr_un)
- He points out that some address structures have other fields so the memset is important.
Bind creates an entry in the file system.
- You can't bind to an existing name.
- It is probably best to bind to a fixed path, so it does not move based on where the program is run.
- only one path per socket and one socket per path.
- open does not work on a socket.
- Use unlink or remove to get rid of the socket after we are finished.
For the examples, we will bind to paths in /tmp
- He says that this is bad for real applications.
- A DOS attack can occur when someone creates these paths in place of the server.
Look at dieServer.cpp.
Note to self, can run nc -uU /tmp/DieServer
- nc is netcat. A utility for this purpose.
- It is a prebuilt client.
- -u says use datagrams
- -U says use unix domain sockets.
- If we wanted a server we could add -l
In the actual client I used a set of stringstreams to move things in and out of buffers.
Otherwise I would have to do this by hand. (loop through, one character at a time)
Or scanf if I were doing this c style.

  ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags,
                        struct sockaddr *restrict src_addr,
                        socklen_t *restrict addrlen);

the socket
The buffer
The size of the buffer
Flags, control non-blocking ect.
The address, this will be filled in.
The length of the address, again, this will be filled in.
If the address is null, nothing will be returned in this parameter.
If there is no message this blocks, unless you set no_block.
Returns bytes received.

  ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);

sockfd is the socket
buf is the data you want to send. In this case I am sending and receiving strings.
len is the size of the buffer you are sending.
Flags let you control blocking ans such.
sockaddr is the address you are sending to.
- This came as a bonus from recvfrom
Since this works with many different socket types, we need the size of the address as well.
If the message is too large, an error is generated.
The address is required in a send in a stream socket, but defiantly for a datagram. (Remember, no connect).

For this setup, you can have multiple clients communicating at the same time.

The previous example was a datagram example.

Let's build a stream example.

The server calcServer.cpp
- socket and bind as before.
- listen
- accept in place of just recvfrom
  - This will return a new fd (new socket)
  - This what you use for the remainder of the connection.
- Next is easy and hard
  - sendto/recvfrom send packets.
    - the other client/server would just read an entire packet.
  - This is a stream.
    - If not careful, messages can become "garbled"
    - There are no boundaries.
  - So a protocol becomes more important.
  - For my server
    - The client will write a byte, indicating the operation to perform.
    - If an operand is required, the client will write a word containing the operand.
    - on quit the server will quit.
    - On =
      - The server will write a word indicating the size of the message to be returned.
      - The server will return a message of the appropriate size as ascii characters.
      - The server will return status (see below)
    - On anything else
      - The server will perform the operation.
      - The server will return status.
    - To return status
      - Send a word indicating the number of characters in the status update.
      - Send the status update.
- Notice, the data persists as long as the connection persists.
The client
- Doesn't need to bind to an address, the connection is set up and maintained.
- It simply does a connect
- and then reads/writes.
- But it must Read/write the correct things.