How do I write to a socket that I created in another file in C?

Question

I have two c files, server and client. The server listens for and accepts a connection request from a client, and then it waits to print out a message given to it by the client. The connection process works perfectly, but I don't know how to get it to relay the message it's supposed to receive.

Since these two files are separate, I'm unsure what file descriptor to put into the write() call in the client. The read() call in the server is called before the write() call in the client, and it uses the file descriptor s2, which is the output from its accept() call.

How can I get the write() call in my client file to talk to the same socket that the read() call in my server file is looking for?

The code below has had some functions like error checking omitted in the interest of time.

Here is the content of my server.c file:

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

     char buffer[257];
     int pipe_fds;
     int psts; // Holds result of pipe creation attempt
     psts = my_pipe(pipe_fds);

     if(psts == 0) { // If pipe is successful
             printf(" SERVER: Server running...\n");
             printf(" SERVER: Waiting for message...\n");
             read(pipe_fds, buffer, 257); // <---------- Output stops here
             printf(" SERVER: Message: %s\n", buffer);

             close(pipe_fds);
     }
     return 0;
}

This is the function my_pipe() used in the above block:

int my_pipe(int fd) {

// SET UP CONNECTION REQUEST SOCKET: S1 -------------------------------------------
    int s1 = socket(AF_UNIX, SOCK_STREAM, 0);
    if(s1 == -1) {return -1;}

    struct sockaddr name1 = {AF_UNIX, "ServerSocket"};
    socklen_t namelen1 = sizeof(struct sockaddr) + 13;
    bind(s1, &name1, namelen1);

    printf("\n SERVER: [s1] Socket Created! \n");

// SET UP LISTEN/ACCEPT -----------------------------------------------------------
    if(listen(s1, 1) == -1) {return -1;}

    printf("\n SERVER: Server Listening! \n\n");

// SET UP CLIENT CONNECTION SOCKET: S2 --------------------------------------------
    struct sockaddr name1_0;
    socklen_t namelen1_0;

    int s2 = accept(s1, &name1_0, &namelen1_0); // <----------- This is where s2 is defined
    if(s2 == -1) {return -1;}
    printf(" SERVER: Client Found...\n");

    fd = s2;
    close(s1);
    return 0;
}

Lastly, this is the content of my client.c file:

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

    char buffer[257];

    // Create a socket to connect to the server with
    int s0 = socket(AF_UNIX, SOCK_STREAM, 0);
    if(s0 == -1) { return -1; }

    // Create a sockaddr for the known existing socket "ServerSocket"
    struct sockaddr server_name = {AF_UNIX, "ServerSocket"};
    socklen_t server_len = sizeof(struct sockaddr) + 13;

    // Connect to "ServerSocket"
    if(connect(s0, &server_name, server_len) == -1) {return -1;}

    printf("CLIENT: Client Connected!\n");
    strcpy(buffer, "This is the Client Message.");
    write([INSERT SERVER SOCKET FD], buffer, strlen(buffer) + 1); // <----- The line in question

    printf("CLIENT: Message Sent!\n");

    close(s0);
    return 0;
}

The output of the server from running both files:

 SERVER: [s1] Socket Created!

 SERVER: Server Listening!

 SERVER: Client Found...
 SERVER: Server running...
 SERVER: Waiting for message...
 (infinite waiting)

Answer 1

Just some pseudo code for the common logic, that may be useful for the general understanding. In simple words you setup the server first and the return from accept gives you the client socket. So you have 2 different sockets. You dont need the server socket anymore and close the server socket, so it can accept further connections (only can accept one at a time). You can take the client socket and pass it to either a function, or fork() or pass it to a thread - all up to you.

     main () {
          int server_socket;
          server_socket = socket(AF_INET, ....);
          init(addrinfo()) // initialize server_socket
          bind //port
          listen // set backlog queue, number of allowed waiting connections)
          while (1) { //loop to wait for incoming connections
              int client_socket = accept(server_socket....) //client connection !
              close(server_socket); // otherwise blocked
              my_pipe(&client_socket) /pass client socket to function
          }

          my_pipe(*socket) {
          read/write //send/recv 
          close(socket);
          }