Example #1
0
/**
* @fn                   :tc_driver_adc_open_close
* @brief                :Test the adc driver open and close
* @scenario             :Test the adc driver open and close
* API's covered         :open, close
* Preconditions         :none
* Postconditions        :none
* @return               :void
*/
static void tc_driver_adc_open_close(void)
{
	int fd = 0;
	int ret = 0;

	/* Positive test cases */
	fd = open("/dev/adc0", O_RDONLY);
	TC_ASSERT_GT("adc_open", fd, 0);

	ret = close(fd);
	TC_ASSERT_EQ("adc_close", ret, OK);

	/* Negative test cases */
	int count = 0;
	int fds[255] = { 0, };
	for (count = 0; count < 255; count++) {
		fds[count] = open("/dev/adc0", O_RDONLY);
		if (fds[count] < 0) {
			TC_ASSERT_EQ_CLEANUP("adc_open", errno, EMFILE, close_fds(fds, --count));
			break;
		}
	}

	close_fds(fds, --count);

	TC_SUCCESS_RESULT();
}
Example #2
0
void
wl_connection_destroy(struct wl_connection *connection)
{
	close_fds(&connection->fds_out, -1);
	close_fds(&connection->fds_in, -1);
	close(connection->fd);
	free(connection);
}
Example #3
0
int main(int argc, char ** argv) {
    ssize_t f1_rs, f2_rs, f3_ws;    // rs = read size, ws = write size
    uint32_t tuple[2], number;

    if (argc != 4) {
        err(1, "Exectly 3 arguments must be passed!");
    }

    if ((fd1 = open(argv[1], O_RDONLY)) == -1) {
        err(1, "Failed opening first file for reading!");
    }

    if ((fd2 = open(argv[2], O_RDONLY)) == -1) {
        close(fd1);
        err(1, "Failed opening second file for reading!");
    }

    if ((fd3 = open(argv[3], O_WRONLY, S_IWUSR)) == -1) {
        close(fd1);
        close(fd2);
        err(1, "Failed opening third file for writing!");
    }

    // прочитаме наредената двойка <x_i, y_i> в tuple масива от uint32_t
    while ((f1_rs = read(fd1, tuple, sizeof(tuple))) > 0) {
        if (f1_rs != sizeof(tuple)) {
            close_fds();
            err(1, "Error while reading tuples from file 1!");
        }

        printf("%d, %d\n", (unsigned int) tuple[0], (unsigned int) tuple[1]);

        // местим f2 до позиция x_i
        lseek(fd2, tuple[0] * sizeof(uint32_t), SEEK_SET);

        // прочитаме y_i на брой uint32_t числа от f2 и ги записваме в f3
        for (uint32_t j = 0; j < tuple[1]; ++j) {

            // за всяко j от [0, y_i) прочитаме число от f2 на позиция (x_i + j)
            lseek(fd2, j * sizeof(uint32_t), SEEK_CUR);

            if ((f2_rs = read(fd2, &number, sizeof(uint32_t))) != sizeof(uint32_t)) {
                close_fds();
                err(1, "Failed reading correctly a number from file 2!");
            }

            // записваме прочетеното число в f3
            if ((f3_ws = write(fd3, &number, sizeof(uint32_t))) != sizeof(uint32_t)) {
                close_fds();
                err(1, "Failed writing correctly a number into file 3!");
            }
        }
    }

    close_fds();
}
Example #4
0
pid_t do_proc_open_helper(int afdt_fd) {
  std::string cmd, cwd;
  std::vector<std::string> env;
  std::vector<int> pvals;
  lwp_read(afdt_fd, cmd, cwd, env, pvals);

  std::vector<int> pkeys;
  for (int i = 0; i < pvals.size(); i++) {
    int fd = recv_fd(afdt_fd);
    if (fd < 0) {
      lwp_write(afdt_fd, "error", (int32_t)EPROTO);
      close_fds(pkeys);
      return -1;
    }
    pkeys.push_back(fd);
  }

  // indicate error if an empty command was received
  if (cmd.length() == 0) {
    lwp_write(afdt_fd, "error", (int32_t)ENOENT);
    return -1;
  }

  // now ready to start the child process
  pid_t child = fork();
  if (child == 0) {
    mprotect_1g_pages(PROT_READ);
    Process::OOMScoreAdj(1000);
    for (int i = 0; i < pvals.size(); i++) {
      dup2(pkeys[i], pvals[i]);
    }
    if (!cwd.empty() && chdir(cwd.c_str())) {
      // non-zero for error
      // chdir failed, the working directory remains unchanged
    }
    if (!env.empty()) {
      char **envp = build_envp(env);
      execle("/bin/sh", "sh", "-c", cmd.c_str(), nullptr, envp);
      free(envp);
    } else {
      execl("/bin/sh", "sh", "-c", cmd.c_str(), nullptr);
    }
    _Exit(HPHP_EXIT_FAILURE);
  }

  if (child > 0) {
    // successfully created the child process
    lwp_write(afdt_fd, "success", child);
  } else {
    // failed creating the child process
    lwp_write(afdt_fd, "error", errno);
  }

  close_fds(pkeys);
  return child;
}
Example #5
0
int
wl_connection_destroy(struct wl_connection *connection)
{
	int fd = connection->fd;

	close_fds(&connection->fds_out, -1);
	close_fds(&connection->fds_in, -1);
	free(connection);

	return fd;
}
Example #6
0
File: main.c Project: EmisFR/burp
int server(struct conf **confs, const char *conffile,
	struct lock *lock, int generate_ca_only)
{
	enum serret ret=SERVER_ERROR;
	int rfds[LISTEN_SOCKETS]; // Sockets for clients to connect to.
	int sfds[LISTEN_SOCKETS]; // Status server sockets.

	//return champ_test(confs);

	init_fds(rfds);
	init_fds(sfds);

	if(ca_server_setup(confs)) goto error;
	if(generate_ca_only)
	{
		logp("The '-g' command line option was given. Exiting now.\n");
		goto end;
	}

	if(get_int(confs[OPT_FORK]) && get_int(confs[OPT_DAEMON]))
	{
		if(daemonise() || relock(lock)) goto error;
	}

	ssl_load_globals();

	while(!gentleshutdown)
	{
		if(run_server(confs, conffile, rfds, sfds))
			goto error;

		if(hupreload && !gentleshutdown)
		{
			if(reload(confs, conffile,
				0, // Not first time.
				get_int(confs[OPT_MAX_CHILDREN]),
				get_int(confs[OPT_MAX_STATUS_CHILDREN])))
					goto error;
		}
		hupreload=0;
	}

end:
	ret=SERVER_OK;
error:
	close_fds(rfds);
	close_fds(sfds);

// FIX THIS: Have an enum for a return value, so that it is more obvious what
// is happening, like client.c does.
	return ret;
}
Example #7
0
/*
This is a wrapper around the system() call to allow commands to run correctly 
as non root from a program which is switching between root and non-root 

It takes 3 arguments as uid,gid,command and runs command after
becoming a non-root user */
 int main(int argc,char *argv[])
{
  uid_t uid;
  gid_t gid;

  close_fds();

  if (argc != 4) exit(2);

  uid = (uid_t)atoi(argv[1]);
  gid = (gid_t)atoi(argv[2]);

  become_user_permanently( uid, gid);

  /* paranoia :-) */
  if (getuid() != uid)
    return(3);

  if (geteuid() != getuid())
    return(4);

  /* this is to make sure that the system() call doesn't run forever */
  alarm(30);

  return(system(argv[3]));
}
Example #8
0
int
pam_modutil_sanitize_helper_fds(pam_handle_t *pamh,
				enum pam_modutil_redirect_fd stdin_mode,
				enum pam_modutil_redirect_fd stdout_mode,
				enum pam_modutil_redirect_fd stderr_mode)
{
	if (stdin_mode != PAM_MODUTIL_IGNORE_FD &&
	    redirect_in_pipe(pamh, STDIN_FILENO, "stdin") < 0) {
		return -1;
	}

	if (redirect_out(pamh, stdout_mode, STDOUT_FILENO, "stdout") < 0)
		return -1;

	/*
	 * If stderr should not be ignored and
	 * redirect mode for stdout and stderr are the same,
	 * optimize by redirecting stderr to stdout.
	 */
	if (stderr_mode != PAM_MODUTIL_IGNORE_FD &&
	    stdout_mode == stderr_mode) {
		if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {
			pam_syslog(pamh, LOG_ERR,
				   "dup2 of %s failed: %m", "stderr");
			return -1;
		}
	} else {
		if (redirect_out(pamh, stderr_mode, STDERR_FILENO, "stderr") < 0)
			return -1;
	}

	close_fds();
	return 0;
}
Example #9
0
int make_daemon(daemon_flag_t flag, long maxfd) {
    int e;

    if ((e = exec_fork()))
        return e;

    if (setsid() == -1)
        return error("creating a new session failed");

    if ((e = exec_fork()))
        return e;

    if (!(flag & daemon_flag_no_close_fds))
        if ((e = close_fds(maxfd)))
            return e;

    if (!(flag & daemon_flag_no_reopen_stdfds))
        if ((e = reopen_stdfds()))
            return e;

    if (atexit(terminate))
        return error("a termination handler could not be installed");

    if (install_default_sigaction_handlers())
        return error("default signal handlers could not be installed");

    return 0;
}
Example #10
0
void dpsx(SRC_NODE *node)
{
     int  retVal;

     start_node = node;
     close_fds();
     if (start_node == NULL)
         return;
     set_times();
     retVal = outputSeq();
     close_fds();
     if (retVal) {
         write_info();
         sprintf(tmpStr, "%s/.dpsViewInfo", curexpdir);
         unixPathToWin(tmpStr, tmpPath, MAXPATH);
         writelineToVnmrJ("dps scopewindow ", tmpPath);
     }
}
Example #11
0
static RETSIGTYPE
got_fatal_signal (int sig)
{
  const char *s;

  if (caught_fatal_sig)
    raise (sig);
  caught_fatal_sig = 1;

  if (cleanup_fnc)
    cleanup_fnc ();
  /* Better don't translate these messages. */
  (void)write (2, "\n", 1 );
  s = log_get_prefix (NULL);
  if (s)
    (void)write(2, s, strlen (s));
  (void)write (2, ": signal ", 9 );
  s = get_signal_name(sig);
  if (s)
    (void) write (2, s, strlen(s) );
  else
    {
      /* We are in a signal handler so we can't use any kind of printf
         even not sprintf.  So we use a straightforward algorithm.  We
         got a report that on one particular system, raising a signal
         while in this handler, the parameter SIG get sclobbered and
         things are messed up because we modify its value.  Although
         this is a bug in that system, we will protect against it.  */
      if (sig < 0 || sig >= 100000)
        (void)write (2, "?", 1);
      else
        {
          int i, value, any=0;

          for (value=sig,i=10000; i; i /= 10)
            {
              if (value >= i || ((any || i==1) && !(value/i)))
                {
                  (void)write (2, "0123456789"+(value/i), 1);
                  if ((value/i))
                    any = 1;
                  value %= i;
                }
            }
        }
    }
  (void)write (2, " caught ... exiting\n", 20);

  /* Reset action to default action and raise signal again */
  init_one_signal (sig, SIG_DFL, 0);
  /* Fixme: remove_lockfiles ();*/
#ifdef __riscos__
  close_fds ();
#endif /* __riscos__ */
  raise( sig );
}
Example #12
0
void	cmd_execution(t_cmd *cmd, t_fds *fd, t_sh *shell)
{
  cmd->pid.pid = -1;

  if (cmd->argv != NULL)
    {
      if (is_cmd_a_builtin(cmd, fd, shell, 1) == 0)
        exec_process(cmd, fd, shell, &my_execve);
    }
  close_fds(fd);
}
Example #13
0
bool LightProcess::initShadow(int afdt_lid,
                              const std::string &afdt_filename, int id,
                              const std::vector<int> &inherited_fds) {
  Lock lock(m_procMutex);

  pid_t child = fork();
  if (child == 0) {
    // child
    Logger::ResetPid();
    pid_t sid = setsid();
    if (sid < 0) {
      Logger::Warning("Unable to setsid");
      exit(HPHP_EXIT_FAILURE);
    }
    afdt_error_t err = AFDT_ERROR_T_INIT;
    m_afdt_fd = afdt_connect(afdt_filename.c_str(), &err);
    if (m_afdt_fd < 0) {
      Logger::Warning("Unable to afdt_connect, filename %s: %d %s",
                      afdt_filename.c_str(),
                      errno, folly::errnoStr(errno).c_str());
      exit(HPHP_EXIT_FAILURE);
    }

    // don't hold on to previous light processes' pipes, inherited
    // fds, or the afdt listening socket
    for (int i = 0; i < id; i++) {
      g_procs[i].closeFiles();
    }
    close_fds(inherited_fds);
    ::close(afdt_lid);

    runShadow();
  } else if (child < 0) {
    // failed
    Logger::Warning("Unable to fork lightly: %d %s", errno,
                    folly::errnoStr(errno).c_str());
    return false;
  } else {
    // parent
    m_shadowProcess = child;

    sockaddr addr;
    socklen_t addrlen = sizeof(addr);
    m_afdt_fd = accept(afdt_lid, &addr, &addrlen);
    if (m_afdt_fd < 0) {
      Logger::Warning("Unable to establish afdt connection: %d %s",
                      errno, folly::errnoStr(errno).c_str());
      closeShadow();
      return false;
    }
  }
  return true;
}
int main(int argc, char **argv)
{
    char data[4];
    int i, res= 0;

    printf("\n"
           "****************************************************************\n"
           "*** NOTE:                                                    ***\n"
           "***       the HAL must be compiled with Low power quaternion ***\n"
           "***           and/or DMP screen orientation support.         ***\n"
           "***       'At least' one of the 4 Android virtual sensors    ***\n"
           "***           must be enabled.                               ***\n"
           "***                                                          ***\n"
           "*** Please perform gestures to see the output.               ***\n"
           "*** Press any key to stop the program.                       ***\n"
           "****************************************************************\n"
           "\n");

    res = inv_init_sysfs_attributes();
    if (res) {
        printf("GT:ERR-Can't allocate mem\n");
        return -1;
    }

    /* init Fds to poll for gesture data */
    init_fds();

    /* on Gesture/DMP supported features */
    if (enable_dmp_features(1) < 0) {
        printf("GT:ERR-Can't enable Gestures\n");
        return -1;
    }

    do {
        for (i = 0; i < NUM_DMP_FEATS; i++)
            read(pfd[i].fd, data, 4);
        poll(pfd, NUM_DMP_FEATS, POLL_TIME);
        parse_events(pfd, NUM_DMP_FEATS);
    } while (!_kbhit());

    /* off Gesture/DMP supported features */
    if (enable_dmp_features(0) < 0) {
        printf("GT:ERR-Can't disable Gestures\n");
        return -1;
    }

    /* release resources */
    close_fds();
    if (sysfs_names_ptr)
        free(sysfs_names_ptr);

    return res;
}
Example #15
0
void do_append_write_test(int* fd, const int fileCount, const int fileSize, 
    const int blockSize, const bool needclose) {

  char buf[MAX_BLOCK_SIZE] = {0};
  if(! needclose) {
    // Do not need close:
    // Open file before the test start, mode O_CREAT|O_APPEND|O_SYNC
    init_fds(fd, fileCount, filename_prefix, path, AW_FILE_MODE);
  }

  char mkdircmd[MAX_STR_LEN] = {0};
  sprintf( mkdircmd, "mkdir -p %s", path);
  system(mkdircmd);

  int i=0;
  int j=0;
  for(; (blockSize * j) < fileSize; j++) {

    for(i=0; i < fileCount; i++) {
      char filename[MAX_FILENAME_LEN];
      snprintf(filename, MAX_FILENAME_LEN, FILENAME_FORMAT, path, filename_prefix, i);
      struct timeval tv_begin, tv_end;    
      gettimeofday(&tv_begin, NULL);
      int cur_fd;
      if(needclose) {
        cur_fd = open(filename, AW_FILE_MODE, 0666);
        if(cur_fd <= 0 ) {
          printf("Open file error: %s\n", filename);
        }
        write(cur_fd, buf, blockSize);
        close(cur_fd);
      } else {
        cur_fd = fd[i];
        write(cur_fd, buf, blockSize);
        fsync(cur_fd);
      }
      gettimeofday(&tv_end, NULL);

      long long elapsed = ( ( tv_end.tv_sec * 1000000 + tv_end.tv_usec)
          - (tv_begin.tv_sec * 1000000 + tv_begin.tv_usec));
      if(needclose) {
        printf("Need Close: ");
      } else {
        printf("Do not need Close: ");
      }
      printf("%ld us\n", elapsed);
    }
  }  
  if(!needclose) {
    close_fds(fd, fileCount);
  }
}
int Process::get_exit_status() {
  if(data.id<=0)
    return -1;
  int exit_status;
  waitpid(data.id, &exit_status, 0);
  close_mutex.lock();
  closed=true;
  close_mutex.unlock();
  
  close_fds();
  
  return exit_status;
}
Example #17
0
int Process::get_exit_status() {
  if(data.id<=0)
    return -1;
  int exit_status;
  waitpid(data.id, &exit_status, 0);
  {
    std::lock_guard<std::mutex> lock(close_mutex);
    closed=true;
  }
  close_fds();

  return exit_status;
}
Example #18
0
void		free_players(t_list *players)
{
  t_player	*player;
  t_action	*action;

  while (players)
    {
      player = players->data;
      while ((action = c_buf_get(&(player->actions))))
	free_action(action);
      players = players->next;
    }
  close_fds(g_zappy->players);
  free_list(g_zappy->players);
}
Example #19
0
int Process::get_exit_status() {
  if(data.id==0)
    return -1;
  DWORD exit_status;
  WaitForSingleObject(data.handle, INFINITE);
  if(!GetExitCodeProcess(data.handle, &exit_status))
    exit_status=-1;
  {
    std::lock_guard<std::mutex> lock(close_mutex);
    CloseHandle(data.handle);
    closed=true;
  }
  close_fds();

  return static_cast<int>(exit_status);
}
Example #20
0
int
wl_connection_flush(struct wl_connection *connection)
{
	struct iovec iov[2];
	struct msghdr msg;
	char cmsg[CLEN];
	int len = 0, count, clen;
	uint32_t tail;

	if (!connection->want_flush)
		return 0;

	tail = connection->out.tail;
	while (connection->out.head - connection->out.tail > 0) {
		wl_buffer_get_iov(&connection->out, iov, &count);

		build_cmsg(&connection->fds_out, cmsg, &clen);

		msg.msg_name = NULL;
		msg.msg_namelen = 0;
		msg.msg_iov = iov;
		msg.msg_iovlen = count;
		msg.msg_control = (clen > 0) ? cmsg : NULL;
		msg.msg_controllen = clen;
		msg.msg_flags = 0;

		do {
			len = sendmsg(connection->fd, &msg,
				      MSG_NOSIGNAL | MSG_DONTWAIT);
		} while (len == -1 && errno == EINTR);

		if (len == -1)
			return -1;

		close_fds(&connection->fds_out, MAX_FDS_OUT);

		connection->out.tail += len;
	}

	connection->want_flush = 0;

	return connection->out.head - tail;
}
Example #21
0
bool Process::try_get_exit_status(int &exit_status) noexcept {
  if(data.id<=0)
    return false;

  id_type p = waitpid(data.id, &exit_status, WNOHANG);
  if (p == 0)
    return false;

  {
    std::lock_guard<std::mutex> lock(close_mutex);
    closed=true;
  }
  close_fds();

  if(exit_status>=256)
    exit_status=exit_status>>8;

  return true;
}
Example #22
0
File: env.c Project: funtoo/vzctl
static int real_env_stop(vps_handler *h, envid_t veid, const char *vps_root,
                         int stop_mode)
{
    int ret;

    if ((ret = vz_chroot(vps_root)))
        return ret;
    if ((ret = vz_setluid(veid)))
        return ret;
    close_fds(1, h->vzfd, -1);
    if ((ret = vz_env_create_ioctl(h, veid, VE_ENTER)) < 0) {
        if (errno == ESRCH)
            return 0;
        logger(-1, errno, "Container enter failed");
        return ret;
    }
    close(h->vzfd);
    switch (stop_mode) {
    case M_REBOOT:
    {
        char *argv[] = {"reboot", NULL};
        execvep(argv[0], argv, NULL);
        break;
    }
    case M_HALT:
    {
        char *argv[] = {"halt", NULL};
        execvep(argv[0], argv, NULL);
        break;
    }
    case M_KILL:
    {
        syscall(__NR_reboot, LINUX_REBOOT_MAGIC1,
                LINUX_REBOOT_MAGIC2,
                LINUX_REBOOT_CMD_POWER_OFF, NULL);
        break;
    }
    }
    return 0;
}
Example #23
0
static int open_fds()
{
     int k, retVal;
     char **labels;
     FILE *fd;
     
     if (imageType)
         labels = image_labels;
     else
         labels = channel_label;
     retVal = 1;
     rfchan[ACQDEV] = 1;
     for (k = 1; k < TOTALCH; k++) {
          fds[k] = NULL;
          items[k] = 0;
          lines[k] = 0;
          // phaseFds[k] = NULL;
          if (rfchan[k] && visibleCh[k]) {
              sprintf(tmpStr, "%s/.dpsChannel%d", curexpdir, k);
              unixPathToWin(tmpStr, tmpPath, MAXPATH);
              fd = fopen(tmpPath, "w");
              if (fd == NULL)
                  retVal = 0;
              fds[k] = fd;
              fprintf(fd, "#channel %d\n", k);
              fprintf(fd, "#name %s\n", labels[k]);
              fprintf(fd, "#seqtime %g\n", seqTime); 
              fprintf(fd, "#columns 6\n");
              fprintf(fd, "#debug  %d\n", debug);
              // fprintf(fd, "#columns %d\n", channel_columns[k]);
              print_dummy(k);
              print_size(k, 1); 
              fprintf(fd, "0.0  0.0  0.0 0 0 1\n");
          }
     }
     if (retVal == 0)
          close_fds();
     return (retVal);
}
Example #24
0
void dpsx_init(int type, int d, char *name)
{
     int i;

     imageType = type;
     debug = d;
     for (i = 0; i < TOTALCH; i++) {
         rfchan[i] = 0;
         visibleCh[i] = 1;
         times[i] = 0.0;
         chX[i] = 0.0;
         chY[i] = 0.0;
         chY2[i] = 0.0;
         phases[i] = 0.0;
         gradMax[i] = 2.0;
         powers[i] = 2.0;
     }
     close_fds();
     strcpy(seqName, "dps");
     if (name != NULL)
         strcpy(seqName, name);
}
Example #25
0
void daemonize(void)
{
	pid_t pid, sid;

	pid = fork();
	if (pid < 0) {
		ALOGE("daemonize failed to fork.");
		exit(1);
	} else if (pid > 0) {
		ALOGI("Sacrificial walnutd child: exiting");
		exit(0);
	}

	/* Obtain a new process group */
	sid = setsid();
	if (sid < 0) {
		fprintf(stderr, "Failed to set sid\n");
		exit(1);
	}
	fprintf(stderr, "Closing all open FDs...\n");
	close_fds();
}
Example #26
0
int                     exec_instr_pipe(s_instr                 *instr,
                                        s_list_dup              *list_dup,
                                        int                     *error)
{
  s_instr_pipe          *instr_pipe = NULL;
  int                   filedes[2];
  int                   res = 0;
  s_list_dup            *dp = NULL;
  s_list_dup            *dp2 = NULL;
  s_list_instr_item     *list_instr = NULL;
  int                   fd_in = STDIN_FILENO;

  if (instr == NULL || instr->instr == NULL)
    return (-1);

  instr_pipe = instr->instr;

  list_instr = instr_pipe->list_instr->first;
  for (; list_instr != NULL; list_instr = list_instr->next)
  {
    if (list_instr->next != NULL)
      mpipe(filedes);
    if (list_instr->next != NULL)
      dp = list_dup_insert(list_dup, filedes[1], STDOUT_FILENO);

    if (list_instr != instr_pipe->list_instr->first)
      dp2 = list_dup_insert(dp == NULL ? list_dup : dp, fd_in, STDIN_FILENO);

    res = exec_instr(list_instr->elmt, dp2 == NULL ? dp : dp2, error);
    close_fds(&fd_in, filedes, list_instr->next);
    free_and_null(&dp, &dp2);

    CHECK_ERROR()
  }

  return (res);
}
Example #27
0
int
wl_connection_data(struct wl_connection *connection, uint32_t mask)
{
	struct iovec iov[2];
	struct msghdr msg;
	char cmsg[CLEN];
	int len, count, clen;

	if (mask & WL_CONNECTION_WRITABLE) {
		wl_buffer_get_iov(&connection->out, iov, &count);

		build_cmsg(&connection->fds_out, cmsg, &clen);

		msg.msg_name = NULL;
		msg.msg_namelen = 0;
		msg.msg_iov = iov;
		msg.msg_iovlen = count;
		msg.msg_control = cmsg;
		msg.msg_controllen = clen;
		msg.msg_flags = 0;

		do {
			len = sendmsg(connection->fd, &msg,
				      MSG_NOSIGNAL | MSG_DONTWAIT);
		} while (len < 0 && errno == EINTR);

		if (len == -1 && errno == EPIPE) {
			return -1;
		} else if (len < 0) {
			fprintf(stderr,
				"write error for connection %p, fd %d: %m\n",
				connection, connection->fd);
			return -1;
		}

		close_fds(&connection->fds_out);

		connection->out.tail += len;
		if (connection->out.tail == connection->out.head &&
		    connection->write_signalled) {
			connection->update(connection,
					   WL_CONNECTION_READABLE,
					   connection->data);
			connection->write_signalled = 0;
		}
	}

	if (mask & WL_CONNECTION_READABLE) {
		wl_buffer_put_iov(&connection->in, iov, &count);

		msg.msg_name = NULL;
		msg.msg_namelen = 0;
		msg.msg_iov = iov;
		msg.msg_iovlen = count;
		msg.msg_control = cmsg;
		msg.msg_controllen = sizeof cmsg;
		msg.msg_flags = 0;

		do {
			len = wl_os_recvmsg_cloexec(connection->fd, &msg, 0);
		} while (len < 0 && errno == EINTR);

		if (len < 0) {
			fprintf(stderr,
				"read error from connection %p: %m (%d)\n",
				connection, errno);
			return -1;
		} else if (len == 0) {
			/* FIXME: Handle this better? */
			return -1;
		}

		decode_cmsg(&connection->fds_in, &msg);

		connection->in.head += len;
	}	

	return connection->in.head - connection->in.tail;
}
Example #28
0
 Process::~Process() {
     close_fds();
 }
Example #29
0
File: launch.c Project: aufau/xqf
int client_launch_exec (int forkit, char *dir, char* argv[], struct server *s) {
	int pid;
	int pipefds[2];
	int flags;
	char msg[CLIENT_ERROR_BUFFER];

	if (get_debug_level() || dontlaunch) {
		char* cmdline = g_strjoinv(" # ",argv);
		debug(0,"%s",cmdline);
		g_free(cmdline);
	}

	if (dontlaunch)
		return -1;

	script_action_gamestart(NULL, s);

	if (forkit) {

		if (pipe (pipefds) < 0) {
			dialog_failed ("pipe", NULL);
			return -1;
		}

		pid = fork ();

		if (pid == -1) {
			dialog_failed ("fork", NULL);
			return -1;
		}

		if (pid) {  /* parent */
			close (pipefds[1]);

			flags = fcntl (pipefds[0], F_GETFL, 0);
			if (flags < 0 || fcntl (pipefds[0], F_SETFL, flags | O_NONBLOCK) < 0) {
				dialog_failed ("fcntl", NULL);
				return -1;
			}

			client_attach (pid, pipefds[0], s);
		}
		else {      /* child */

			close_fds(pipefds[1]);

			if (dir && dir[0] != '\0') {
				if (chdir (dir) != 0) {
					g_snprintf (msg, CLIENT_ERROR_BUFFER, "%schdir failed: %s", 
							CLIENT_ERROR_MSG_HEAD, g_strerror (errno));
					goto error_out;
				}
			}


			server_set_env(s);

			execvp (argv[0], argv);

			g_snprintf (msg, CLIENT_ERROR_BUFFER, "%sexec(%s) failed: %s", 
					CLIENT_ERROR_MSG_HEAD, argv[0], g_strerror (errno));

			error_out:
			write (pipefds[1], msg, strlen (msg) + 1);
			close (pipefds[1]);

			on_sig (SIGHUP,  _exit);
			on_sig (SIGINT,  _exit);
			on_sig (SIGQUIT, _exit);
			on_sig (SIGBUS,  _exit);
			on_sig (SIGSEGV, _exit);
			on_sig (SIGPIPE, _exit);
			on_sig (SIGTERM, _exit);
			on_sig (SIGALRM, _exit);
			on_sig (SIGCHLD, SIG_DFL);

			_exit (1);
		}
		return pid;
	}

	execvp (argv[0], argv);

	dialog_failed ("exec", argv[0]);
	return -1;
}
Example #30
0
int main(int argc, char **argv)
{
	int ret = EXIT_SUCCESS;
	int i;
	struct passwd *pwd;
	static FILE *fp;
	char *to_chdir;
	char *from_user;
	char *cwd = get_current_dir_name();
	char cmdpath[PATH_MAX];

	if (argc < 3) {
		fprintf(stderr, "Usage: runasuser user program [args ...]\n");
		ret = EXIT_FAILURE;
		goto out;
	}

	pwd = getpwnam(argv[1]);
	if (!pwd) {
		fprintf(stderr, "Error: No such user %s\n", argv[1]);
		ret = EXIT_FAILURE;
		goto out;
	}

	fp = fopen("/etc/runasuser.conf", "r");
	if (!fp) {
		fp = fopen("/usr/local/etc/runasuser.conf", "r");
		if (!fp) {
			perror("fopen runasuser.conf");
			ret = EXIT_FAILURE;
			goto out;
		}
	}

	/* Check the user calling runasuser */
	pwd = getpwuid(getuid()); /* Yes, we want the _real_ uid */
	from_user = pwd->pw_name;
	/* Allow root to run as any user */
	if (getuid() > 0) {
		if (!check_user_auth(from_user, argv[1], fp)) {
			fprintf(stderr, "Error: You are not authorized to run "
					"as %s\n", argv[1]);
			ret = EXIT_FAILURE;
			goto out;
		}
	}
	fclose(fp);

	/* Drop all supplementary groups of the calling user */
	if (setgroups(0, NULL) != 0) {
		perror("setgroups");
		ret = EXIT_FAILURE;
		goto out;
	}

	pwd = getpwnam(argv[1]);
	/*
	 * Set the supplementary groups for the new user
	 *
	 * This needs to come before setuid() as this needs the
	 * CAP_SETGID capability
	 */
	if (initgroups(pwd->pw_name, pwd->pw_gid) != 0) {
		perror("initgroups");
		ret = EXIT_FAILURE;
		goto out;
	}

	/*
	 * Order is important, if setuid comes first,
	 * then the setgid is unable to perform.
	 */
	if (setgid(pwd->pw_gid) != 0) {
		perror("setgid");
		ret = EXIT_FAILURE;
		goto out;
	}
	if (setuid(pwd->pw_uid) != 0) {
		/* It's important to bail if the setuid() fails. */
		perror("setuid");
		ret = EXIT_FAILURE;
		goto out;
	}

	/*
	 * Check whether to chdir() into the users home directory
	 *
	 * Needs to come before clearenv()
	 *
	 * YES, if RUNASUSER_CHDIR = 1 (default)
	 * NO, if RUNASUSER_CHDIR = 0
	 */
	to_chdir = getenv("RUNASUSER_CHDIR");
	if (!to_chdir || atoi(to_chdir) != 0) {
		if (chdir(pwd->pw_dir) != 0) {
			perror("chdir");
			ret = EXIT_FAILURE;
			goto out;
		}
	}

	/* Clear the shell environment before setting up a new one */
	if (clearenv() != 0) {
		perror("clearenv");
		ret = EXIT_FAILURE;
		goto out;
	}
	if (setenv("HOME", pwd->pw_dir, 1) != 0) {
		SETENV_ERR("HOME");
		ret = EXIT_FAILURE;
		goto out;
	}
	if (setenv("USER", pwd->pw_name, 1) != 0) {
		SETENV_ERR("USER");
		ret = EXIT_FAILURE;
		goto out;
	}
	if (setenv("RUNASUSER_USER", from_user, 1) != 0) {
		SETENV_ERR("RUNASUSER_USER");
		ret = EXIT_FAILURE;
		goto out;
	}
	if (setenv("PATH", "/usr/local/bin:/bin:/usr/bin", 1) != 0) {
		SETENV_ERR("PATH");
		ret = EXIT_FAILURE;
		goto out;
	}
	/* Read the rest of the environment from the config file */
	fp = fopen("/etc/runasuser.env.conf", "r");
	if (!fp)
		fp = fopen("/usr/local/etc/runasuser.env.conf", "r");
	if (fp) {
		if (!setup_environment(pwd->pw_name, fp)) {
			ret = EXIT_FAILURE;
			goto out;
		}
		fclose(fp);
	}

	/* check if the command to run exists */
	if (!command_found(argv[2], cmdpath)) {
		fprintf(stderr, "runasuser: %s: command not found\n", argv[2]);
		ret = EXIT_FAILURE;
		goto out;
	}

	printf("Execing [ ");
	for (i = 2; i < argc; i++)
		printf("%s ", argv[i]);

	printf("]\n");

	/* Log info to syslog, same format as sudo */
	ret = do_log(from_user, pwd->pw_name, cwd, cmdpath, argv);
	if (!ret) {
		ret = EXIT_FAILURE;
		goto out;
	}

	/* Close all open file descriptors above 2 */
	close_fds();

	if (execvp(argv[2], argv + 2) == -1) {
		perror("exec");
		ret = EXIT_FAILURE;
	}

out:
	free(cwd);
	exit(ret);
}