void zmq::session_t::process_attach (i_engine *engine_,
    const blob_t &peer_identity_)
{
    //  If we are already terminating, we destroy the engine straight away.
    //  Note that we don't have to unplug it before deleting as it's not
    //  yet plugged to the session.
    if (state == terminating) {
        if (engine_)
            delete engine_;
        return;
    }

    //  If some other object (e.g. init) notifies us that the connection failed
    //  without creating an engine we need to start the reconnection process.
    if (!engine_) {
        zmq_assert (!engine);
        detached ();
        return;
    }

    //  Trigger the notfication event about the attachment.
    if (!attached (peer_identity_)) {
        delete engine_;
        return;
    }

    //  Check whether the required pipes already exist. If not so, we'll
    //  create them and bind them to the socket object.
    if (!pipes_attached) {
        zmq_assert (!in_pipe && !out_pipe);
        pipes_attached = true;
        reader_t *socket_reader = NULL;
        writer_t *socket_writer = NULL;

        //  Create the pipes, as required.
        if (options.requires_in) {
            create_pipe (socket, this, options.hwm, options.swap,
                &socket_reader, &out_pipe);
            out_pipe->set_event_sink (this);
        }
        if (options.requires_out) {
            create_pipe (this, socket, options.hwm, options.swap, &in_pipe,
                &socket_writer);
            in_pipe->set_event_sink (this);
        }

        //  Bind the pipes to the socket object.
        if (socket_reader || socket_writer)
            send_bind (socket, socket_reader, socket_writer, peer_identity_);
    }

    //  Plug in the engine.
    zmq_assert (!engine);
    engine = engine_;
    engine->plug (io_thread, this);
}

/**
 * Called by the main function of the game. Intializes the client network component of the game.
 * Requires 2 pipes as arguments, these will be passed for communication to network router. The
 * read descriptor of rcv_router_fd will be passed to the update system by the game, while the
 * write descriptor of the send_router_fd will be passed to the send_system.
 *
 * @param[in]   send_router_fd      Set of pipes created for passing data to the network router.
 * @param[in]   rcv_router_fd       Set of pipes created for grabbing data from the network router.
 *
 * @return      void
 *
 * @designer    Ramzi Chennafi
 * @author      Ramzi Chennafi
 */
void init_client_network(int send_router_fd[2], int rcv_router_fd[2], char * ip)
{
    pthread_t thread;
    PDATA pdata = (PDATA) malloc(sizeof(WTHREAD_DATA));

    create_pipe(send_router_fd);
    create_pipe(rcv_router_fd);

    pdata->read_pipe = send_router_fd[READ_END];
    pdata->write_pipe = rcv_router_fd[WRITE_END];
    memcpy(pdata->ip, ip, MAXIP);

    pthread_create(&thread, NULL, networkRouter, (void *)pdata);
    pthread_detach(thread);
}

void zmq::session_t::process_attach (i_engine *engine_,
    const blob_t &peer_identity_)
{
    //  If some other object (e.g. init) notifies us that the connection failed
    //  we need to start the reconnection process.
    if (!engine_) {
        zmq_assert (!engine);
        detached ();
        return;
    }

    //  If we are already terminating, we destroy the engine straight away.
    if (finalised) {
        delete engine;
        return;
    }

    //  Check whether the required pipes already exist. If not so, we'll
    //  create them and bind them to the socket object.
    reader_t *socket_reader = NULL;
    writer_t *socket_writer = NULL;

    if (options.requires_in && !out_pipe) {
        create_pipe (socket, this, options.hwm, options.swap, &socket_reader,
            &out_pipe);
        out_pipe->set_event_sink (this);
    }

    if (options.requires_out && !in_pipe) {
        create_pipe (this, socket, options.hwm, options.swap, &in_pipe,
            &socket_writer);
        in_pipe->set_event_sink (this);
    }

    if (socket_reader || socket_writer)
        send_bind (socket, socket_reader, socket_writer, peer_identity_);

    //  Plug in the engine.
    zmq_assert (!engine);
    zmq_assert (engine_);
    engine = engine_;
    engine->plug (io_thread, this);

    attach_processed = true;

    //  Trigger the notfication about the attachment.
    attached (peer_identity_);
}

void fb_hooks(const ALLEGRO_EVENT & event){
    switch(event.type){
        case ALLEGRO_EVENT_KEY_DOWN:
            keys[event.keyboard.keycode]=true;
            switch(event.keyboard.keycode){
                case ALLEGRO_KEY_SPACE:
                    if(!has_lost)
                        bird->im.rotation_vel=-(2.0f/3.0f)*(bird->im.rotation+PI/2);
                    break;
                case ALLEGRO_KEY_R:
                    clear_pipes();
                    break;
                case ALLEGRO_KEY_ESCAPE:
                    if(!show_menu){
                        show_menu=true;
                        menu->active=true;
                        start_button->active=true;
                        quit_button->active=true;
                        has_lost=true;
                    }else
                        quit_at_next_frame();
                    break;
            }
            break;
        case ALLEGRO_EVENT_KEY_UP:
            keys[event.keyboard.keycode]=false;
            break;
        case ALLEGRO_EVENT_TIMER:
            if(event.timer.source==fb_timer)
                create_pipe();
            break;
    }
}

void make_loop(int n, int* last_pipe, char* grammar) {
    /* last_pipe[0] = input of the recently created pipe    *
     * last_pipe[1] = output of the first pipe              */
	pid_t pid;
	if (n == 1) {
		prepare_input(last_pipe);
        prepare_output(last_pipe);
        close_pipe(last_pipe);
        return;
	}
	int next_pipe[2];
    create_pipe(next_pipe);
	switch (pid = fork()) {
		case -1:
			syserr("Error in fork()\n");
		case 0:
			prepare_input(last_pipe);
            close_pipe(last_pipe);
            prepare_output(next_pipe);
            close_pipe(next_pipe);
			execl("./worker", "./worker", grammar, NULL);
			syserr("Error in execl()\n");
		default:
            last_pipe[0] = next_pipe[0];
            make_loop(n - 1, last_pipe, grammar);
            return;
	}
}

int execute_command_line(char *line, char *argv[]) {

    int  num_of_commands = 0;
    enum cmd_pos pos     = unknown;
    int  left_pipe[2]    = {-1, -1};
    int  right_pipe[2]   = {-1, -1};

    do {

        // Repeat this loop for each of the commands separated by '|' in
        // the command pipeline.

        // Use the next_command() parser to get the position and argument
        // vector of the next command in the command pipeline.
        pos = next_command(line, argv);

        create_pipe(pos, right_pipe);


        fork_child(pos, left_pipe, right_pipe, argv);

        // Only the parent will return here!!!

        num_of_commands++;

        // The previous rigth pipe now becomes the current left pipe.
        shift_pipes(left_pipe, right_pipe);


    } while (pos != single && pos != last);

    return num_of_commands;
}

static int vloopback_open(struct file *f)
#endif
{    
    struct video_device *loopdev = video_devdata(f);
    
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)    
    priv_ptr ptr = (priv_ptr)dev_get_drvdata(&loopdev->dev);
#else
    priv_ptr ptr = (priv_ptr)loopdev->vd_private_data;
#endif    
    int nr = ptr->pipenr;

    if (debug > LOG_NODEBUG)
        info("Video loopback %d", nr);    

    /* Only allow a output to be opened if there is someone feeding
     * the pipe.
     */
    if (!ptr->in) {
        if (loops[nr]->buffer == NULL) 
            return -EINVAL;
        
        loops[nr]->framesread = 0;
        loops[nr]->ropen = 1;
    } else {
        if (loops[nr]->ropen || loops[nr]->wopen) 
            return -EBUSY;

        loops[nr]->framesdumped = 0;
        loops[nr]->frameswrite = 0;
        loops[nr]->wopen = 1;
        loops[nr]->zerocopy = 0;
        loops[nr]->ioctlnr = -1;
        pipesused++;
        if (nr_o_pipes-pipesused<spares) {
            if (!create_pipe(nr_o_pipes)) {
                info("Creating extra spare pipe");
                info("Loopback %d registered, input: video%d, output: video%d",
                    nr_o_pipes,
                    loops[nr_o_pipes]->vloopin->minor,
                    loops[nr_o_pipes]->vloopout->minor
                );
                nr_o_pipes++;
            }
        }
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
        loops[nr]->pid = current->pid;
#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30)        
        loops[nr]->pid = find_vpid(current->pid);
#else
        // TODO : Check in stable 2.6.27
        loops[nr]->pid = task_pid(find_task_by_vpid(current->pid));
        //loops[nr]->pid = task_pid(current);
#endif        

        if (debug > LOG_NODEBUG)
            info("Current pid %d", current->pid);
    }
    return 0;
}

void WinListener::create_pipe()
{
    _pipe = CreateNamedPipe(_pipename, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
                            PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
                            PIPE_UNLIMITED_INSTANCES, PIPE_BUF_SIZE, PIPE_BUF_SIZE,
                            PIPE_TIMEOUT, NULL);
    if (_pipe == INVALID_HANDLE_VALUE) {
        THROW("CreateNamedPipe() failed %u", GetLastError());
    }
    if (ConnectNamedPipe(_pipe, &_overlap)) {
        THROW("ConnectNamedPipe() is not pending");
    }
    switch (GetLastError()) {
    case ERROR_IO_PENDING:
        DBG(0, "Pipe waits for connection");
        break;
    case ERROR_PIPE_CONNECTED: {
        DBG(0, "Pipe already connected");
        WinConnection *con = new WinConnection(_pipe, _process_loop);
        NamedPipe::ConnectionInterface &con_interface = _listener_interface.create();
        con->set_handler(&con_interface);
        con_interface.bind((NamedPipe::ConnectionRef)con);
        create_pipe();
        break;
    }
    default:
        THROW("ConnectNamedPipe() failed %u", GetLastError());
    }
}

int     check_ops(char *str, t_tree *tree)
{
  if (tree->parent != NULL)
    {
      if ((my_strcmp(tree->parent->str, ">") == 0
           || my_strcmp(tree->parent->str, ">>") == 0)
          && tree == tree->parent->right)
        return (0);
      if ((my_strcmp(tree->parent->str, "<") == 0)
          && tree == tree->parent->right)
        return (0);
    }
  if (my_strcmp(str, ";") == 0)
    return (0);
  else if (my_strcmp(str, "&&") == 0)
    return (0);
  else if (my_strcmp(str, "||") == 0)
    return (0);
  else if (my_strcmp(str, "|") == 0)
    {
      create_pipe(tree);
      return (0);
    }
  else
    return (check_ops2(str, tree));
}

int main(int argc, char* argv[]) {
	int n,i;
	int last_pipe[2];
    struct grammar g;

	if (argc != 4) {
		fatal("Usage: %s <workers number> <grammar file> <starting symbol>\n",
            argv[0]);
	}
	n = atoi(argv[1]);
	if (n <= 0) {
		fatal("Number of workers should be a positive integer");
	}
    if (strlen(argv[3]) != 1 || !is_upper(argv[3][0])) {
        fatal("Starting symbol should be a single nonterminal (uppercase)\n");
    }

    create_pipe(last_pipe);
	make_loop(n, last_pipe, argv[2]);

    read_grammar(&g, argv[2]);
    work(&g, argv[3][0]);

    for (i = 1; i < n; i++) {
		if (wait(0) == -1) syserr("Error in wait()\n");
	}
	return 0;
}

int	exec_a_pipe(t_sh *shell, t_grp *grp)
{
  t_fds	fd;
  int	ptab[2];
  t_cmd	*tmpcmd;
  int	i;

  i = 0;
  ptab[PIPE_READ] = -1;
  ptab[PIPE_WRITE] = -1;
  init_stdfd_t_def_val(&fd, grp->fd.stdin, grp->fd.stdout, grp->fd.stderr);
  if (grp->cmds == NULL)
    return (-1);
  while ((tmpcmd = grp->cmds[i]) != NULL)
    {
      if (create_pipe(grp, ptab, &fd, i) == -1)
        return (-1);
      cmd_execution(tmpcmd, &fd, shell);
      if (MEXIT)
        return (0);
      group_to_process_group(grp, tmpcmd);
      init_stdfd_t_def_val(&fd, grp->fd.stdin, grp->fd.stdout, grp->fd.stderr);
      if (grp->cmds[i + 1] != NULL)
        fd.stdin = ptab[PIPE_READ];
      i++;
    }
  return (0);
}

void ShZshapeManager::create_shape(const char* content)
{
	if (content == "cube")
	{
		create_cube();
	}

	if (content == "cylinder")
	{
		create_cylinder();
	}

	if (content == "pipe")
	{
		create_pipe();
	}

	if (content == "cone")
	{
		create_cone();
	}

	if (content == "circle")
	{
		create_circle();
	}

	if (content == "ring")
	{
		create_ring();
	}

	if (content == "pyramid")
	{
		create_pyramid();
	}

	if (content == "triangle")
	{
		create_triangle();
	}

	if (content == "rectangle")
	{
		create_rectangle();
	}

	if (content == "polygon")
	{
		create_polygon();
	}

	if (content == "multigonalStar")
	{
		create_multigonalStar();
	}

}

// This method creates the named pipes used to communicate with the webservice
void create_pipes() {
	char nomepipe[1024];

	// This file will contain the username of the user to be authenticated
	sprintf(nomepipe, "%s%s", PREFIX, sessionID);
	write_file(&nomepipe[0], username, 1);

	// This pipe contains the text of the question to be presented to the user
	sprintf(nomepipe, "%s%s_testo", PREFIX, sessionID);
	create_pipe(&nomepipe[0]);

	// This pipe contains the type of the question to be presented to the user
	sprintf(nomepipe, "%s%s_tipo", PREFIX, sessionID);
	create_pipe(&nomepipe[0]);

	// This pipe is used to collect the response of the user to the question
	sprintf(nomepipe, "%s%s_risposta", PREFIX, sessionID);
	create_pipe(&nomepipe[0]);
}

void tester_util::redirect(const ProcessPointer &from, const int from_fd,
                           const ProcessPointer &to, const int to_fd) {
  try {
    const Pipe pipe = create_pipe();
    from->setStream(from_fd, pipe.writeEnd());
    to->setStream(to_fd, pipe.readEnd());
  } catch (std::exception &) {
    BOOST_THROW_EXCEPTION(redirect_error() << bunsan::enable_nested_current());
  }
}

/* creates an array containing all the PIDs of the child processes */
void spawn_sorts(int **in_pipe, int **out_pipe)
{
	//Spawn all the sort processes
	process_array = malloc(sizeof(pid_t) * num_sorts);
	pid_t pid;
        int i;
        for (i = 0; i < num_sorts; i++){
                create_pipe(in_pipe[i]);
                create_pipe(out_pipe[i]);  
                switch(pid = fork()){
                        case -1: //Oops case
                                puke_and_exit("Forking error\n");
                        case 0: //Child case
			        close(STDIN_FILENO);
			        close(STDOUT_FILENO);
			        if (in_pipe[i][0] != STDIN_FILENO) {	//Defensive check
					if (dup2(in_pipe[i][0], STDIN_FILENO) ==
					    -1)
						puke_and_exit("dup2 0");
				}
				/* Bind stdout to out_pipe*/
				close_pipe(out_pipe[i][0]);	//close read end of output pipe
				if (out_pipe[i][1] != STDOUT_FILENO) {	//Defensive check
					if (dup2(out_pipe[i][1], STDOUT_FILENO) ==
					    -1)
						puke_and_exit("dup2 1");
				}
                                /* 
                                Pipes from previously-spawned children are still open in this child
                                Close them and close the duplicate pipes just created by dup2 
                                */
                                close_pipes_array(in_pipe, i+1);
                                close_pipes_array(out_pipe, i+1);
                                execlp("sort", "sort", (char *)NULL);
                        default: //Parent case
                                process_array[i] = pid;
                                close_pipe(in_pipe[i][0]);
                		close_pipe(out_pipe[i][1]);
                                break; 
                }
        }
}

int main(int argc, char **argv)
{
  //char *pathname = "special_file";
  int err;
  int num = 1000;
  char *dir = ".";
  char *dirname = "block_dir";
  char *dirname_char = "char_dir";
  char *dirname_pipe = "pipe_dir";
  char *dirname_regular_file = "file_dir";
  char *entries_dir_path;  

  if(argv[1])
    num = atoi(argv[1]);
  
  printf("%d\n",num);
  if ( ulimit_unlimited() == -1 ) {
    fprintf(stderr, "%s:ulimit failed going with default value, Setting %d to 1000\n",
	    strerror(errno),num);
    num = 1000;
  }
  /* Creating 1000 block special files and calculating the time needed for it */
  entries_dir_path = getcwd(entries_dir_path,255);
  mkdir (dirname,0755);
  strcat(entries_dir_path,dirname);
  create_block_special_file(dirname,num);
  rmdir(dirname);

  /* Creating 1000 cgaracter special files and calculating the time needed for it */
  entries_dir_path = getcwd(entries_dir_path,255);
  mkdir (dirname_char,0755); 
  strcat(entries_dir_path,dirname_char);
  create_character_special_file(dirname_char,num);
  rmdir(dirname_char);

  /*Creating 1000 directories and calculating the time needed for it */
  create_directory(dir,num);

  /* Creating 1000 files and calculating the time needed for it */
  entries_dir_path = getcwd(entries_dir_path,255);
  mkdir (dirname_pipe,0755); 
  strcat(entries_dir_path,dirname_pipe);
  create_pipe(dirname_pipe,num);
  rmdir(dirname_pipe);

  /* Creating 1000 regular files and calculating the time needed for it */
  entries_dir_path = getcwd(entries_dir_path,255);
  mkdir (dirname_regular_file,0755); 
  strcat(entries_dir_path,dirname_regular_file);
  create_regular_file(dirname_regular_file,num);
  rmdir(dirname_regular_file);
  
  return 0;
}

FXbool Signal::create() {
#if defined(_WIN32)
  device=CreateEvent(nullptr,true,false,nullptr);
  if (device==BadHandle) return false;
#elif defined(HAVE_EVENTFD)
  device=eventfd(0,EFD_CLOEXEC|EFD_NONBLOCK);
  if (device==BadHandle) return false;
#else
  if (!create_pipe(device,wrptr)) return false;
#endif
  return true;
  }

static void test_create(void)
{
    HANDLE hserver;
    NTSTATUS res;
    int j, k;
    FILE_PIPE_LOCAL_INFORMATION info;
    IO_STATUS_BLOCK iosb;

    static const DWORD access[] = { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ | GENERIC_WRITE};
    static const DWORD sharing[] =    { FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE };
    static const DWORD pipe_config[]= {               1,                0,                                  2 };

    for (j = 0; j < sizeof(sharing) / sizeof(DWORD); j++) {
        for (k = 0; k < sizeof(access) / sizeof(DWORD); k++) {
            HANDLE hclient;
            BOOL should_succeed = TRUE;

            res  = create_pipe(&hserver, sharing[j], FILE_SYNCHRONOUS_IO_NONALERT);
            if (res) {
                ok(0, "NtCreateNamedPipeFile returned %x, sharing: %x\n", res, sharing[j]);
                continue;
            }

            res = pNtQueryInformationFile(hserver, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
            ok(!res, "NtQueryInformationFile for server returned %x, sharing: %x\n", res, sharing[j]);
            ok(info.NamedPipeConfiguration == pipe_config[j], "wrong duplex status for pipe: %d, expected %d\n",
               info.NamedPipeConfiguration, pipe_config[j]);

            hclient = CreateFileW(testpipe, access[k], 0, 0, OPEN_EXISTING, 0, 0);
            if (hclient != INVALID_HANDLE_VALUE) {
                res = pNtQueryInformationFile(hclient, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
                ok(!res, "NtQueryInformationFile for client returned %x, access: %x, sharing: %x\n",
                   res, access[k], sharing[j]);
                ok(info.NamedPipeConfiguration == pipe_config[j], "wrong duplex status for pipe: %d, expected %d\n",
                   info.NamedPipeConfiguration, pipe_config[j]);
                CloseHandle(hclient);
            }

            if (access[k] & GENERIC_WRITE)
                should_succeed &= !!(sharing[j] & FILE_SHARE_WRITE);
            if (access[k] & GENERIC_READ)
                should_succeed &= !!(sharing[j] & FILE_SHARE_READ);

            if (should_succeed)
                ok(hclient != INVALID_HANDLE_VALUE, "CreateFile failed for sharing %x, access: %x, GetLastError: %d\n",
                   sharing[j], access[k], GetLastError());
            else
                ok(hclient == INVALID_HANDLE_VALUE, "CreateFile succeeded for sharing %x, access: %x\n", sharing[j], access[k]);

            CloseHandle(hserver);
        }
    }
}

WinListener::WinListener(const char *name, NamedPipe::ListenerInterface &listener_interface,
                         ProcessLoop& process_loop)
    : _listener_interface (listener_interface)
    , _pipe (0)
    , _process_loop (process_loop)
{
    _pipename = new TCHAR[PIPE_MAX_NAME_LEN];
    swprintf_s(_pipename, PIPE_MAX_NAME_LEN, L"%s%S", PIPE_PREFIX, name);
    ZeroMemory(&_overlap, sizeof(_overlap));
    _overlap.hEvent = this->get_handle();
    _process_loop.add_handle(*this);
    create_pipe();
}

/* Open a bidirectional pipe.
 *
 *           write       system                read
 *    parent  ->   fd[1]   ->   STDIN_FILENO    ->   child
 *    parent  <-   fd[0]   <-   STDOUT_FILENO   <-   child
 *           read        system                write
 *
 */
pid_t
create_pipe_bidi (const char *progname,
                  const char *prog_path, char **prog_argv,
                  bool null_stderr,
                  bool slave_process, bool exit_on_error,
                  int fd[2])
{
  pid_t result = create_pipe (progname, prog_path, prog_argv,
                              true, true, NULL, NULL,
                              null_stderr, slave_process, exit_on_error,
                              fd);
  return result;
}