Question

Write two C programs that run a server program and a client program concurrently.

Server program:

The server program provides a simple search for a specific value in an array sent to it from a client. If the value appears in the array, the server indicates the index of the first occurrence of that value in the array. The server sends the client search value and its array position. If the value does not occur in the array, only the search value and an appropriate return code is returned to the client.

The server program needs to:

• Determine an integer value to be searched for
• Create a well-known FIFO, named FIFO_to_Server through which the server reads inputs from the client
• Open FIFO_to_Server in READ mode
• Read a request from a client that includes a struct containing a size integer and array values of that size, all integers.
• Find the index (start counting with zero) of the search value, if one exists
• Create a FIFO named FIFO_to_Client through which the server responds to the client
• Open FIFO_to_Client in WRITE mode
• Write the search value and the index position back to the client through FIFO_to_Client
• Close FIFO_to_Client
• Unlink FIFO_to_Client
• Close FIFO_to_Server
• Unlink FIFO_to_Server

Client Program:

The client program will request an array size and array elements to fill the array. The client program should:

• Open FIFO_to_Server in WRITE mode
• Prompt the user for an array size
• Prompt the user for elements to fill that array
• Write the struct that includes the array size and the array to FIFO_to_Server
• Close FIFO_to_Server ^*
• Open the FIFO_to_Client in READ mode
• Read the response from the server from FIFO_to_Client
• Print a message such as “The value 87 occurs in array position 4”
• Close FIFO_to Client

Answer 1

Client:

// ClientTest.c
// opens fifo1 for writing and fifo2 for reading


#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>


struct problem {        
    char letter[1];
    int number[1];
};
main (void)
{
  struct problem x; 
  int fda;  // to write to character server
  int fdb;  // to read response from character server
  int i;    // for the iteration

  memset(&x, 0, sizeof(struct problem)) ;


  printf("Client: Please enter a character: ");
  scanf("%c", x.letter); 
  printf("Client: Please enter an integer: ");
  scanf("%d", x.number);  

// removed or else the letter and number would be reverted to zero
 // memset(&x.letter, 0, sizeof(char));
//  memset(&x.number, 0, sizeof(int));  


  if((fda=open("FIFO_to_Server", O_WRONLY))<0)//opening and validating fifos
     printf("cant open fifo to write");

  if((fdb=open("FIFO_to_Client", O_RDONLY))<0)
     printf("cant open fifo to read");

  write(fda, x.letter, sizeof(char));
  printf("\nClient: Got the character sent, now waiting for response ");

  write(fda, x.number, sizeof(int));
  printf("\nClient: Got the integer sent, now waiting for response ");
  //sleep(0.250);

  char outletter[7];

  read(fdb, outletter, 7);
  printf("\nClient: received characters from server:") ;
  printf("%s\n", outletter);

  close(fda);
  close(fdb);


  printf ("\nall done!\n");

}

Server:

// ServerTest.c
// makes 2 fifos named fifo1 and fifo2
// opens fifo1 for reading and fifo2 for writing

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

struct problem {
    char letter[1]; // struct to store the character
    int number[1]; // struct to store the integer
    };

main (void)
{
  struct problem x;
  int fda;  // to read from client char
  int fdb;  // to write to client char
  int finish;   // lets me know that client is done
  int i;    // because C needs this defined as int
  int p;
  char outletter[7];

  memset(x.letter, 0, sizeof(char));
  memset(x.number, 0, sizeof(int));


  /* Create the fifos and open them  */
  if ((mkfifo("FIFO_to_Server",0666)<0 && errno != EEXIST))
    {
    perror("cant create FIFO_to_Server");
    exit(-1);
    }
  if ((mkfifo("FIFO_to_Client",0666)<0 && errno != EEXIST))
    {
    perror("cant create FIFO_to_Client");
    exit(-1);
    }
  if((fda=open("FIFO_to_Server", O_RDONLY))<0)
     printf("cant open fifo to write");
  if((fdb=open("FIFO_to_Client", O_WRONLY))<0)
     printf("cant open fifo to read");

  read(fda, x.letter, sizeof(char)); //read the character
  read(fda, x.number, sizeof(int));   //read the integer


  printf("\nServer: just got character: , %c", x.letter[0]);
  printf("\nServer: just got integer: , %d", x.number[0]);

  p=x.number[0];



  if (p > 6) p = 6;  // Cannot write more than 6 characters in outletter



  for( i = 0; i<=p; i++) {               // iteration to create the character's string
    outletter[i] = x.letter[0];
    printf("iteration: %d and character: %c\n", i, outletter[i]); // validating the character and integer received
  }
  outletter[p] = '\0'; // the string must finish with '\0'


  printf("\nServer: outchar is, %s", outletter); // this shows the character to be sent back to client

  write(fdb, outletter, p); 
  printf("\nServer: Got the characters sent: %s", outletter ); // this sends the letter back to client



  if(finish == 1)
    printf("\nServer: This says I am ready to close ");
  close(fda);
  close(fdb);
  unlink("FIFO_to_Server");
  unlink("FIFO_to_Client");
}