unix_sys_utils.cpp File Reference

#include "unix_sys_utils.hpp"
#include "analyze.hpp"
#include "tm_timer.hpp"
#include <fcntl.h>
#include <pthread.h>
#include <pwd.h>
#include <spawn.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

Include dependency graph for unix_sys_utils.cpp:

Go to the source code of this file.

Classes
struct	_mutex
struct	_mutex_lock
struct	_ts_string
struct	_pipe_t
struct	_channel
struct	_file_actions_t

Functions
SN	unix_get_process_id ()
void *	_ts_malloc (int n)
void	_ts_free (void *a)
static void *	_background_read_task (void *channel_as_void_ptr)
static void *	_background_write_task (void *channel_as_void_ptr)
static void	_unix_system_warn (pid_t pid, string which, string msg)
int	unix_system (array< string > arg, array< int > fd_in, array< string > str_in, array< int > fd_out, array< string * > str_out)
string	unix_get_login ()
string	unix_get_username ()

Variables
char **	environ
static _mutex	_ts_memory_lock

Function Documentation

unix_get_process_id()

SN unix_get_process_id

(

)

Definition at line 25 of file unix_sys_utils.cpp.

                       {
  return getpid ();
}

_ts_malloc()

void * _ts_malloc

(

int

n

)

Definition at line 51 of file unix_sys_utils.cpp.

                   {
  _mutex_lock lock (_ts_memory_lock);
  return malloc (n);
}

_ts_free()

void _ts_free

(

void *

a

)

Definition at line 57 of file unix_sys_utils.cpp.

                   {
  _mutex_lock lock (_ts_memory_lock);
  free (a);
}

_background_read_task()

static void * _background_read_task ( void * channel_as_void_ptr )

static

Definition at line 139 of file unix_sys_utils.cpp.

                                                  {
  _channel* c = (_channel*) channel_as_void_ptr;
  int       fd= c->fd;
  int       n = c->buffer_size;
  char*     b = A (c->buffer);
  int       m;
  do {
    m= read (fd, b, n);
    // cout << "read " << m << " bytes from " << fd << "\n";
    if (m > 0) c->data.append (b, m);
    if (m == 0) {
      if (close (fd) != 0) c->status= -1;
    }
  } while (m > 0);
  return (void*) NULL;
}

_background_write_task()

static void * _background_write_task ( void * channel_as_void_ptr )

static

Definition at line 158 of file unix_sys_utils.cpp.

                                                   {
  _channel*   c = (_channel*) channel_as_void_ptr;
  int         fd= c->fd;
  const char* d = c->data.a;
  int         n = c->buffer_size;
  int         t= (c->data).n, k= 0, o= 0;
  if (t == 0) return (void*) NULL;
  if (n == 0) {
    c->status= -1;
    return (void*) NULL;
  }
  do {
    int m= min (n, t - k);
    // cout << "writting " << m << " bytes / " << t-k << "\n";
    o= write (fd, (void*) (d + k), m);
    // cout << "written " << o << " bytes to " << fd << "\n";
    if (o > 0) k+= o;
    if (o < 0) {
      close (fd);
      c->status= -1;
    }
    if (k == t) {
      if (close (fd) != 0) c->status= -1;
    }
  } while (o > 0 && k < t);
  return (void*) NULL;
}

_unix_system_warn()

static void _unix_system_warn ( pid_t pid, string which, string msg )

static

Definition at line 197 of file unix_sys_utils.cpp.

                                                        {
  (void) which;
}

unix_system()

int unix_system	(	array< string >	arg,
		array< int >	fd_in,
		array< string >	str_in,
		array< int >	fd_out,
		array< string * >	str_out )

Definition at line 202 of file unix_sys_utils.cpp.

                                                        {
  // Run command arg[0] with arguments arg[i], i >= 1.
  // str_in[i] is sent to the file descriptor fd_in[i].
  // str_out[i] is filled from the file descriptor fd_out[i].
  // If str_in[i] is -1 then $$i automatically replaced by a valid
  // file descriptor in arg.
  if (N (arg) == 0) return 0;
  string which= recompose (arg, " ");
  int    n_in= N (fd_in), n_out= N (fd_out);
  ASSERT (N (str_in) == n_in, "size mismatch");
  ASSERT (N (str_out) == n_out, "size mismatch");
  array<_pipe_t>  pp_in (n_in), pp_out (n_out);
  _file_actions_t file_actions;
  for (int i= 0; i < n_in; i++) {
    if (posix_spawn_file_actions_addclose (&file_actions.rep,
                                           pp_in[i].out ()) != 0)
      return -1;
    if (fd_in[i] >= 0) {
      if (posix_spawn_file_actions_adddup2 (&file_actions.rep, pp_in[i].in (),
                                            fd_in[i]) != 0)
        return -1;
      if (posix_spawn_file_actions_addclose (&file_actions.rep,
                                             pp_in[i].in ()) != 0)
        return -1;
    }
  }
  for (int i= 0; i < n_out; i++) {
    if (posix_spawn_file_actions_addclose (&file_actions.rep,
                                           pp_out[i].in ()) != 0)
      return -1;
    if (posix_spawn_file_actions_adddup2 (&file_actions.rep, pp_out[i].out (),
                                          fd_out[i]) != 0)
      return -1;
    if (posix_spawn_file_actions_addclose (&file_actions.rep,
                                           pp_out[i].out ()) != 0)
      return -1;
  }
  array<string> arg_= arg;
  for (int j= 0; j < N (arg); j++)
    for (int i= 0; i < n_in; i++)
      if (fd_in[i] < 0)
        arg_[j]=
            replace (arg_[j], "$$" * as_string (i), as_string (pp_in[i].in ()));
  array<char*> _arg;
  for (int j= 0; j < N (arg_); j++)
    _arg << as_charp (arg_[j]);
  _arg << (char*) NULL;
  pid_t pid;
  int   status=
      posix_spawnp (&pid, _arg[0], &file_actions.rep, NULL, A (_arg), environ);
  for (int j= 0; j < N (arg_); j++)
    tm_delete_array (_arg[j]);
  if (status != 0) {
    return -1;
  }
  // close useless ports
  for (int i= 0; i < n_in; i++)
    close (pp_in[i].in ());
  for (int i= 0; i < n_out; i++)
    close (pp_out[i].out ());
 
  // write to spawn process
  array<_channel>  channels_in (n_in);
  array<pthread_t> threads_write (n_in);
  for (int i= 0; i < n_in; i++) {
    channels_in[i]._init_in (pp_in[i].out (), str_in[i], 1 << 12);
    if (pthread_create (&threads_write[i], NULL /* &attr */,
                        _background_write_task, (void*) &(channels_in[i])))
      return -1;
  }
 
  // read from spawn process
  array<_channel>  channels_out (n_out);
  array<pthread_t> threads_read (n_out);
  for (int i= 0; i < n_out; i++) {
    channels_out[i]._init_out (pp_out[i].in (), 1 << 12);
    if (pthread_create (&threads_read[i], NULL /* &attr */,
                        _background_read_task, (void*) &(channels_out[i])))
      return -1;
  }
 
  int    wret;
  time_t last_wait_time= texmacs_time ();
  while ((wret= waitpid (pid, &status, WNOHANG)) == 0) {
    usleep (100);
    if (texmacs_time () - last_wait_time > 5000) {
      last_wait_time= texmacs_time ();
      _unix_system_warn (pid, which, "waiting spawn process");
    }
  }
 
  // wait for terminating threads
  void* exit_status;
  int   thread_status= 0;
  for (int i= 0; i < n_in; i++) {
    pthread_join (threads_write[i], &exit_status);
    if (channels_in[i].status < 0) thread_status= -1;
  }
  for (int i= 0; i < n_out; i++) {
    pthread_join (threads_read[i], &exit_status);
    *(str_out[i])= string (channels_out[i].data.a, channels_out[i].data.n);
    if (channels_out[i].status < 0) thread_status= -1;
  }
 
  if (thread_status < 0) return thread_status;
  if (wret < 0 || WIFEXITED (status) == 0) return -1;
  return WEXITSTATUS (status);
}

unix_get_login()

string unix_get_login

(

)

Definition at line 313 of file unix_sys_utils.cpp.

                  {
  uid_t          uid= getuid ();
  struct passwd* pwd= getpwuid (uid);
  return string (pwd->pw_name);
}

unix_get_username()

string unix_get_username

(

)

Definition at line 320 of file unix_sys_utils.cpp.

                     {
  uid_t          uid= getuid ();
  struct passwd* pwd= getpwuid (uid);
  return tokenize (string (pwd->pw_gecos), string (","))[0];
}

Variable Documentation

environ

char** environ

extern

_ts_memory_lock

_mutex _ts_memory_lock

static

Definition at line 48 of file unix_sys_utils.cpp.