106 lines
3.5 KiB
C++
106 lines
3.5 KiB
C++
//
|
|
// Boost.Process
|
|
// ~~~~~~~~~~~~~
|
|
//
|
|
// Copyright (c) 2006, 2007 Julio M. Merino Vidal
|
|
// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
|
|
// Copyright (c) 2009 Boris Schaeling
|
|
// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
/**
|
|
* \file boost/process/detail/posix_helpers.hpp
|
|
*
|
|
* Includes the declaration of helper functions for POSIX systems.
|
|
*/
|
|
|
|
#ifndef BOOST_PROCESS_POSIX_HELPERS_HPP
|
|
#define BOOST_PROCESS_POSIX_HELPERS_HPP
|
|
|
|
#include <boost/process/config.hpp>
|
|
#include <boost/process/environment.hpp>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <cstring>
|
|
#include <cstddef>
|
|
|
|
namespace boost {
|
|
namespace process {
|
|
namespace detail {
|
|
|
|
/**
|
|
* Converts an environment to a char** table as used by execve().
|
|
*
|
|
* Converts the environment's contents to the format used by the
|
|
* execve() system call. The returned char** array is allocated
|
|
* in dynamic memory; the caller must free it when not used any
|
|
* more. Each entry is also allocated in dynamic memory and is a
|
|
* NULL-terminated string of the form var=value; these must also be
|
|
* released by the caller.
|
|
*
|
|
* This operation is only available on POSIX systems.
|
|
*
|
|
* \return The first argument of the pair is an integer that indicates
|
|
* how many strings are stored in the second argument. The
|
|
* second argument is a NULL-terminated, dynamically allocated
|
|
* array of dynamically allocated strings representing the
|
|
* enviroment's content. Each array entry is a NULL-terminated
|
|
* string of the form var=value. The caller is responsible for
|
|
* freeing them.
|
|
*/
|
|
inline std::pair<std::size_t, char**> environment_to_envp(const environment
|
|
&env)
|
|
{
|
|
std::size_t nargs = env.size();
|
|
char **envp = new char*[nargs + 1];
|
|
environment::size_type i = 0;
|
|
for (environment::const_iterator it = env.begin(); it != env.end(); ++it)
|
|
{
|
|
std::string s = it->first + "=" + it->second;
|
|
envp[i] = new char[s.size() + 1];
|
|
std::strncpy(envp[i], s.c_str(), s.size() + 1);
|
|
++i;
|
|
}
|
|
envp[i] = 0;
|
|
return std::pair<std::size_t, char**>(nargs, envp);
|
|
}
|
|
|
|
/**
|
|
* Converts the command line to an array of C strings.
|
|
*
|
|
* Converts the command line's list of arguments to the format expected
|
|
* by the \a argv parameter in the POSIX execve() system call.
|
|
*
|
|
* This operation is only available on POSIX systems.
|
|
*
|
|
* \return The first argument of the pair is an integer that indicates
|
|
* how many strings are stored in the second argument. The
|
|
* second argument is a NULL-terminated, dynamically allocated
|
|
* array of dynamically allocated strings holding the arguments
|
|
* to the executable. The caller is responsible for freeing them.
|
|
*/
|
|
template <class Arguments>
|
|
inline std::pair<std::size_t, char**> collection_to_argv(const Arguments &args)
|
|
{
|
|
std::size_t nargs = args.size();
|
|
char **argv = new char*[nargs + 1];
|
|
typename Arguments::size_type i = 0;
|
|
for (typename Arguments::const_iterator it = args.begin(); it != args.end();
|
|
++it)
|
|
{
|
|
argv[i] = new char[it->size() + 1];
|
|
std::strncpy(argv[i], it->c_str(), it->size() + 1);
|
|
++i;
|
|
}
|
|
argv[nargs] = 0;
|
|
return std::pair<std::size_t, char**>(nargs, argv);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|