Descriptor receiver

#include <iostream>
#include <sys/socket.h>
#include <unistd.h>
#include <string.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 <pthread.h>
using namespace std;
#define SOCK_PATH "server"

static int recv_file_descriptor(int socket){
 int sent_fd;
 struct msghdr message;
 struct iovec iov[1];
 struct cmsghdr *control_message = NULL;
 char ctrl_buf[CMSG_SPACE(sizeof(int))];
 char data[1];
 int res;

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

 /* For the dummy data */
 iov[0].iov_base = data;
 iov[0].iov_len = sizeof(data);

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

 if((res = recvmsg(socket, &message, 0)) <= 0)
  {	perror("recvmsg");
  	return res;}

 /* Iterate through header to find if there is a file descriptor */
 for(control_message = CMSG_FIRSTHDR(&message);
     control_message != NULL;
     control_message = CMSG_NXTHDR(&message,
                                   control_message))
 {
  if( (control_message->cmsg_level == SOL_SOCKET) &&
      (control_message->cmsg_type == SCM_RIGHTS) )
  {
   return *((int *) CMSG_DATA(control_message));
  }
 }

 return -1;
}

int usfd;
static int recvfd(int socket){
    struct msghdr msg = {0};

    char m_buffer[256];
    struct iovec io = { .iov_base = m_buffer, .iov_len = sizeof(m_buffer) };
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;

    char c_buffer[256];
    msg.msg_control = c_buffer;
    msg.msg_controllen = sizeof(c_buffer);

    if (recvmsg(socket, &msg, 0) < 0)
        printf("Failed to receive message\n");

    struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);

    unsigned char * data = CMSG_DATA(cmsg);

    printf("About to extract fd\n");
    int fd = *((int*) data);
    printf("Extracted fd %d\n", fd);

    return fd;
}
static int recvfd2(int socket){
  struct msghdr msg = {0};

    /* On Mac OS X, the struct iovec is needed, even if it points to minimal data */
    char m_buffer[1];
    struct iovec io = { .iov_base = m_buffer, .iov_len = sizeof(m_buffer) };
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;

    char c_buffer[256];
    msg.msg_control = c_buffer;
    msg.msg_controllen = sizeof(c_buffer);

    if (recvmsg(socket, &msg, 0) < 0)
       printf("Failed to receive message\n");

    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);

    printf("About to extract fd\n");
    int fd;
    memmove(&fd, CMSG_DATA(cmsg), sizeof(fd));
   printf("Extracted fd %d\n", fd);

    return fd;
}
int main(){
char buf[100];
int len;
struct sockaddr_un server;
pthread_t thread;
server.sun_family=AF_LOCAL;
strcpy(server.sun_path,SOCK_PATH);
len=strlen(server.sun_path)+sizeof(server.sun_family);
usfd=socket(AF_LOCAL,SOCK_STREAM,0);
connect(usfd,(struct sockaddr *)&server,len);
perror("connect");
char msg[50];
strcpy(msg,"this is service 1 : \n");
cout<<msg;
while(1){
   char msg[50];
  int fd;
  fd_set fds,master;
  FD_ZERO(&fds);
  FD_SET(usfd,&fds);
  master = fds;
  int nsfd[100];
  int current=1,i,k;
  nsfd[0]=3;
  dup2(0,nsfd[0]);
  while(1){
      cout<<"checking\n";
      fds = master;
      select(FD_SETSIZE,&fds,NULL,NULL,NULL);
      for(i=0;i<current;i++){
          if(FD_ISSET(nsfd[i],&fds)){
            k = recv(nsfd[i],msg,50,0);
            if(k<0||k==0){
              FD_CLR(nsfd[i],&master);
            }
            else{
              sprintf(msg,"%d\n\0",k);
              send(nsfd[i],msg,strlen(msg),0);
            }
          }
      }
      if(FD_ISSET(usfd,&fds)){
          nsfd[current] = recvfd2(usfd);
          FD_SET(nsfd[current],&master);
          cout<<"recv"<<nsfd[current]<<"\n";
          current++;
      }
  }
}
return 0;
}