main server

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>

using namespace std;

#define MAX_SERVICE 1
#define SOCK_PATH "server"

int nsfd[100];

void init(bool arr[]){
	for(int i=0;i<MAX_SERVICE;i++)
		arr[i]=false;
}
int sendfd(int sock, int fd)
{
  struct msghdr hdr;
  struct iovec data;

  char cmsgbuf[CMSG_SPACE(sizeof(int))];

  char dummy = '*';
  data.iov_base = &dummy;
  data.iov_len = sizeof(dummy);

  memset(&hdr, 0, sizeof(hdr));
  hdr.msg_name = NULL;
  hdr.msg_namelen = 0;
  hdr.msg_iov = &data;
  hdr.msg_iovlen = 1;
  hdr.msg_flags = 0;

  hdr.msg_control = cmsgbuf;
  hdr.msg_controllen = CMSG_LEN(sizeof(int));

  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);
  cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
  cmsg->cmsg_level = SOL_SOCKET;
  cmsg->cmsg_type  = SCM_RIGHTS;

  *(int*)CMSG_DATA(cmsg) = fd;

  int n = sendmsg(sock, &hdr, 0);

  if(n == -1)
    printf("sendmsg() failed: %s (socket fd = %d)\n", strerror(errno), sock);

  return n;
}
static int send_file_descriptor(int socket, int fd_to_send) {
 struct msghdr message;
 struct iovec iov[1];
 struct cmsghdr *control_message = NULL;
 char ctrl_buf[CMSG_SPACE(sizeof(int))];
 char data[1];

 memset(&message, 0, sizeof(struct msghdr));
 memset(ctrl_buf, 0, CMSG_SPACE(sizeof(int)));

 /* We are passing at least one byte of data so that recvmsg() will not return 0 */
 data[0] = ' ';
 iov[0].iov_base = data;
 iov[0].iov_len = sizeof(data);

 message.msg_name = NULL;
 message.msg_namelen = 0;
 message.msg_iov = iov;
 message.msg_iovlen = 1;
 message.msg_controllen =  CMSG_SPACE(sizeof(int));
 message.msg_control = ctrl_buf;

 control_message = CMSG_FIRSTHDR(&message);
 control_message->cmsg_level = SOL_SOCKET;
 control_message->cmsg_type = SCM_RIGHTS;
 control_message->cmsg_len = CMSG_LEN(sizeof(int));

 *((int *) CMSG_DATA(control_message)) = fd_to_send;

 sendmsg(socket, &message, 0);
 perror("sendmsg");
 return 1;
}
int sendfd2(int socket, int fd){
	struct msghdr msg = { 0 };
    char buf[CMSG_SPACE(sizeof(fd))];
    memset(buf, '\0', sizeof(buf));

    /* On Mac OS X, the struct iovec is needed, even if it points to minimal data */
    struct iovec io;
     io.iov_base = (void*)("");
     io.iov_len = 1;

    msg.msg_iov = &io;
    msg.msg_iovlen = 1;
    msg.msg_control = buf;
    msg.msg_controllen = sizeof(buf);

    struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(fd));

    memmove(CMSG_DATA(cmsg), &fd, sizeof(fd));

    msg.msg_controllen = cmsg->cmsg_len;

    if (sendmsg(socket, &msg, 0) < 0)
       printf("Failed to send message\n");
}
int make(int i){
	    int c=fork();
		if(c==0){
			dup2(nsfd[i],0);
			execlp("./s1","s1",NULL);
		}
		else return 0;
}

int main(){
unlink(SOCK_PATH);
bool service[MAX_SERVICE];
char buf[50];
int sfd,len,ulen;
int ucfd[MAX_SERVICE];
int usfd;

init(service);

sockaddr_in server,client;
sockaddr_un usvr,uclr;

len=sizeof(server);

//sfd inital-----------------------
server.sin_family=AF_INET;
server.sin_port=htons(8888);
server.sin_addr.s_addr=INADDR_ANY;


//usfd inital------------------------------
usvr.sun_family=AF_UNIX;
strcpy(usvr.sun_path,SOCK_PATH);
ulen=strlen(usvr.sun_path)+sizeof(usvr.sun_family);


//sfd---------------------
sfd=socket(AF_INET,SOCK_STREAM,0);
bind(sfd,(struct sockaddr *)&server,sizeof(server));
perror("bind");

listen(sfd,3);


//usfd-------------------------
usfd=socket(AF_UNIX,SOCK_STREAM,0);
bind(usfd,(struct sockaddr *)&usvr,ulen);
perror("unixBind");

listen(usfd,5);


char mkv[100];
strcpy(mkv,"yoyo for the client to announce the type of service : \n");
fd_set fds,master;
FD_ZERO(&fds);
FD_SET(sfd,&fds);
FD_SET(usfd,&fds);
master = fds;
int current=0,i,k;


while(1){
	fds  = master;
	k = select(FD_SETSIZE,&fds,NULL,NULL,NULL);
	if(FD_ISSET(sfd,&fds)){
		nsfd[current++] =accept(sfd,(struct sockaddr * )&client,(socklen_t *)&len);
		FD_SET(nsfd[current-1],&master);
	    perror("accept");
	}
	for(i=0;i<current;i++){
		if(FD_ISSET(nsfd[i],&fds)){
			k = recv(nsfd[i],buf,100,0);
			if(k<0||k==0){
				FD_CLR(nsfd[i],&master);
			}
			else{
				k  = atoi(buf);
				k--;
				if(k >= 0 && k < MAX_SERVICE ){
					if(service[k]==false){
						    make(i);
							ucfd[0]=accept(usfd,(struct sockaddr *)&uclr,(socklen_t *)&ulen);
							perror("unix accept");
							service[0]=true;
					}
					else{
						sendfd2(ucfd[0],nsfd[i]);
					}
				}
			}
		}
	}
}
return 0;
}