Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/ncbi__pipe_8cpp_source.html below:

NCBI C++ ToolKit: src/connect/ncbi_pipe.cpp Source File

rv = ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_MAX_WIDTH_MASK |

FORMAT_MESSAGE_IGNORE_INSERTS,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

errstr = errmsg.c_str();

::LocalFree((HLOCAL) tmpstr);

retval.

() ? retval.

() : message;

+ where +

+ what;

* timeout,

* exitcode)

(x_exitcode < 0) {

}

(!exitinfo.

()) {

x_exitcode = -(exitinfo.

() + 1000);

x_timeout;

(!timeout || (timeout->

| timeout->

)) {

killed = process.

(x_timeout);

*exitcode = x_exitcode;

vector<string>& args)

(

&& arg : args) {

(

== ERROR_NO_DATA ||

== ERROR_BROKEN_PIPE ||

== ERROR_PIPE_NOT_CONNECTED ?

:

);

& current_dir,

*

envp[],

m_Flags(0), m_SelfHandles(

)

vector<string>& args,

& current_dir,

*

envp[],

(

.find_first_of(

) ==

) {

& comspec =

->Get(

);

(x_cmd_line.empty()) {

x_cmd_line = cmd_line;

(envp[

]) {

env_block.

(block);

(

= 0;

<

; ++

) {

=

.size();

memcpy(block,

.data(),

*

(

));

block[

++] =

(

);

= strlen(envp[

]) + 1;

memcpy(block, envp[

],

);

*block =

(

);

stdout_handle = ::GetStdHandle(STD_OUTPUT_HANDLE);

(stdout_handle ==

) {

stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);

(stderr_handle ==

) {

::FlushFileBuffers(stdout_handle);

::FlushFileBuffers(stderr_handle);

SECURITY_ATTRIBUTES attr;

attr.nLength =

(attr);

attr.bInheritHandle =

;

attr.lpSecurityDescriptor =

;

&attr, (

) pipe_size)) {

);

::SetHandleInformation(

, HANDLE_FLAG_INHERIT, 0);

(!::CreatePipe(&

, &child_stdout, &attr, 0)) {

);

::SetHandleInformation(

, HANDLE_FLAG_INHERIT, 0);

(!::CreatePipe(&

, &child_stderr, &attr, 0)) {

);

::SetHandleInformation(

, HANDLE_FLAG_INHERIT, 0);

current_process = ::GetCurrentProcess();

(!::DuplicateHandle(current_process, stderr_handle,

current_process, &child_stderr,

0,

, DUPLICATE_SAME_ACCESS)) {

);

child_stderr = child_stdout;

PROCESS_INFORMATION pinfo;

::ZeroMemory(&pinfo,

(pinfo));

::ZeroMemory(&sinfo,

(sinfo));

sinfo.cb =

(sinfo);

sinfo.hStdError = child_stderr;

sinfo.hStdOutput = child_stdout;

sinfo.hStdInput = child_stdin;

sinfo.dwFlags = STARTF_USESTDHANDLES;

dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;

dwCreationFlags = 0;

dwCreationFlags |= CREATE_NEW_PROCESS_GROUP;

(!::CreateProcess(

,

dwCreationFlags, env_block.

(),

+ cmd_line +

);

(

& what) {

kZeroZimeout = {0, 0};

(0, &kZeroZimeout);

&& child_stderr != child_stdout) {

);

);

);

(!(from_handle & (from_handle - 1)));

bytes_avail = 0;

x_sleep = 1;

(x_timeout != INFINITE) {

(x_sleep > x_timeout) {

x_timeout -= x_sleep;

(bytes_avail >

) {

= ::ReadFile(fd,

, bytes_avail, &bytes_avail,

);

*n_read = (size_t) bytes_avail;

(

& what) {

* n_written,

* timeout)

(!n_written || !*n_written);

bytes_written = 0;

x_sleep = 1;

&bytes_written,

);

(x_timeout != INFINITE) {

(x_sleep > x_timeout) {

x_timeout -= x_sleep;

*n_written = bytes_written;

(

& what) {

);

(

& what) {

(from_handle) {

= PIPE_READMODE_BYTE | PIPE_NOWAIT;

(!::SetNamedPipeHandleState(fd, &

,

,

)) {

);

x_sleep = 1;

bytes_avail = 0;

&bytes_avail,

)) {

);

}

(bytes_avail) {

bytes_avail = 0;

&bytes_avail,

)) {

);

}

(bytes_avail) {

(x_timeout != INFINITE) {

(x_sleep > x_timeout) {

x_timeout -= x_sleep;

vector<string>& args,

& current_dir,

*

envp[],

: m_ChildStdIn(-1), m_ChildStdOut(-1), m_ChildStdErr(-1),

m_Pid((

)(-1)), m_Flags(0), m_SelfHandles(

)

m_UsePoll = s_UsePoll->

();

[[noreturn]]

s_Exit(

status,

fd)

errcode = errno;

(void) ::write(fd, &errcode,

(errcode));

(void) ::

(fd);

s_ExecShell(

*

,

*

argv[],

*

envp[],

kDefaultShell[] =

;

(

= 0; argv[

]; ++

);

xshell = xenv.

(

);

* shell = xshell.empty() ? kDefaultShell : xshell.c_str();

** args =

*[

+ 1];

(;

> 1; --

) {

args[

] = argv[

- 1];

return ::execve(shell, (

**) args, envp);

s_ExecVPE(

*

,

*

argv[],

*

envp[])

kDefaultPath[] =

;

(strchr(

,

)) {

::execve(

, argv, envp);

errno == ENOEXEC ? s_ExecShell(

, argv, envp, *

) : -1;

& xpath =

->Get(

);

* path = xpath.empty() ? kDefaultPath : xpath.c_str();

file_len = strlen(

) + 1

;

*

=

[strlen(path) + 1

+ file_len];

eacces_err =

;

*

= strchr(path,

);

=

? (size_t)(

- path) : strlen(path)

;

(

[

- 1] !=

) {

::execve(

, argv, envp);

((

= errno) == ENOEXEC) {

s_ExecShell(

, argv, envp, *

);

x_SafeFD(

fd,

safe)

(fd == safe || fd > STDERR_FILENO) {

temp = ::fcntl(fd, F_DUPFD, STDERR_FILENO + 1);

x_SafePipe(

pipe[2],

,

safe)

retval =

;

((pipe[0] = x_SafeFD(pipe[0],

== 0 ? safe : -1)) == -1) {

}

((pipe[1] = x_SafeFD(pipe[1],

== 1 ? safe : -1)) == -1) {

vector<string>& args,

& current_dir,

*

envp[],

(m_Pid != (

)(-1)) {

pipe_in[2], pipe_out[2], pipe_err[2];

status_pipe[2] = {-1, -1};

(::pipe(pipe_in) < 0

);

(::pipe(pipe_out) < 0

);

(::pipe(pipe_err) < 0

|| !x_SafePipe(pipe_err, 1, STDERR_FILENO)) {

);

(::pipe(status_pipe) < 0

|| !x_SafePipe(status_pipe, -1, -1)) {

);

::fcntl(status_pipe[1], F_SETFD,

::fcntl(status_pipe[1], F_GETFD, 0) | FD_CLOEXEC);

** argv =

*[args.size() + 2];

argv[

= 0] =

.c_str();

(

&& arg : args) {

argv[++

] = arg.c_str();

(m_Pid = ::fork()) {

s_Exit(-1, status_pipe[1]);

(void) ::freopen(

,

, stdin);

s_Exit(-1, status_pipe[1]);

(void) ::freopen(

,

, stdout);

(pipe_err[1] != STDERR_FILENO) {

(::dup2(pipe_err[1], STDERR_FILENO) < 0) {

s_Exit(-1, status_pipe[1]);

s_Exit(-1, status_pipe[1]);

(void) ::freopen(

,

, stderr);

::signal(SIGPIPE, SIG_DFL);

(!current_dir.empty() && current_dir !=

) {

(void) ::chdir(current_dir.c_str());

status = execvpe(argv[0],

**

(argv),

**

(envp));

status = ::execvp(argv[0],

**

(argv));

s_Exit(status, status_pipe[1]);

status_pipe[1] = -1;

((

= ::read(status_pipe[0], &errcode,

(errcode))) < 0) {

status_pipe[0] = -1;

status = eIO_Closed;

::waitpid(m_Pid,

, 0);

((

)

<

(errcode) ? 0 : errcode,

(

& what) {

(pipe_in[0] != -1) {

(pipe_out[1] != -1) {

(pipe_err[1] != -1) {

(status_pipe[0] != -1) {

(status_pipe[1] != -1) {

(m_Pid != (

)(-1)) {

m_Pid = (

)(-1);

(m_Pid == (

)(-1)) {

status = eIO_Closed;

(!n_read || !*n_read);

(!(from_handle & (from_handle - 1)));

(m_Pid == (

)(-1)) {

(bytes_read >= 0) {

*n_read = (size_t) bytes_read;

(

== EAGAIN ||

== EWOULDBLOCK) {

((timeout && !(timeout->

| timeout->

))

|| !

(from_handle, timeout)) {

(

!= EINTR) {

(

& what) {

* n_written,

* timeout)

(!n_written || !*n_written);

(m_Pid == (

)(-1)) {

status = eIO_Closed;

(bytes_written >= 0) {

*n_written = (size_t) bytes_written;

(errno == EAGAIN || errno == EWOULDBLOCK) {

((timeout && !(timeout->

| timeout->

))

(errno != EINTR) {

(

== EPIPE) {

status = eIO_Closed;

(

& what) {

(m_Pid == (

)(-1)) {

);

(

& what) {

(from_handle) {

(::fcntl(fd, F_SETFL, ::fcntl(fd, F_GETFL, 0) | O_NONBLOCK) < 0) {

);

poll_fds[3] = {

timeout_msec(timeout

? timeout->

* 1000 + (timeout->

+ 500) / 1000

poll_fds[0].

= -1;

poll_fds[1].

= -1;

poll_fds[2].

= -1;

=

(poll_fds, 3, timeout_msec);

((

= errno) != EINTR) {

timeval*

;

tmo.tv_sec = timeout->

;

tmo.tv_usec = timeout->

;

+

= ::select(

+ 1,

wr ? &wfds : 0, &efds,

);

((

= errno) != EINTR) {

);

: m_PipeSize(pipe_size),

m_PipeHandle(new

), m_ReadHandle(eStdOut),

m_ReadStatus(eIO_Closed), m_WriteStatus(eIO_Closed),

m_ReadTimeout(0), m_WriteTimeout(0), m_CloseTimeout(0)

vector<string>& args,

& current_dir,

*

envp[],

: m_PipeSize(pipe_size),

m_PipeHandle(0), m_ReadHandle(eStdOut),

m_ReadStatus(eIO_Closed), m_WriteStatus(eIO_Closed),

m_ReadTimeout(0), m_WriteTimeout(0), m_CloseTimeout(0)

unique_ptr<CPipeHandle> pipe_handle_ptr(

);

status = pipe_handle_ptr->Open(

, args, create_flags,

current_dir, envp, pipe_size);

+

(

(status)));

vector<string>& args,

& current_dir,

*

envp[],

(

& err) {

(from_handle ==

) {

(from_handle ==

) {

(direction) {

vector<string>& args,

& current_dir,

*

envp[],

ktm = *kill_timeout;

pipe(pipe_size);

pipe.

(&exit_code);

buf_size = 16 * 1024;

buf_size = 192 * 1024;

bytes_in_inbuf = 0;

bytes_written = 0;

load_in =

;

kNoWait = {0, 0};

kWait = {1, 0};

((rmask &

) || load_in) {

done_in =

;

(!bytes_in_inbuf) {

}

((bytes_in_inbuf =

(

,

.get(), buf_size)) != 0) {

}

(!

.good()) {

}

(!(rmask & ~

)) {

(bytes_in_inbuf && (rmask &

)) {

status = pipe.

(

.get() + bytes_written,

bytes_in_inbuf, &x_written);

bytes_in_inbuf -= x_written;

(bytes_in_inbuf) {

}

(!bytes_in_inbuf) {

bytes_written += x_written;

status = pipe.

(

.get(), buf_size, &x_read);

.write(

.get(), x_read);

err.write(

.get(), x_read);

(watcher->

(pid)) {

pipe.

(&exit_code);

pipe.

(&exit_code);

(GetErrCode()) {

eOpen:

;

ncbi::TMaskedQueryRegions mask

static CNcbiApplication * Instance(void)

Singleton method.

EIO_Status CloseHandle(CPipe::EChildIOHandle handle)

CPipe::TChildPollMask Poll(CPipe::TChildPollMask mask, const STimeout *timeout) const

EIO_Status Write(const void *data, size_t count, size_t *written, const STimeout *timeout) const

void x_SetNonBlockingMode(HANDLE fd) const

CPipe::TCreateFlags m_Flags

EIO_Status Read(void *buf, size_t count, size_t *n_read, const CPipe::EChildIOHandle from_handle, const STimeout *timeout) const

CPipe::TChildPollMask x_Poll(CPipe::TChildPollMask mask, const STimeout *timeout) const

TProcessHandle GetProcessHandle(void) const

EIO_Status Open(const string &cmd, const vector< string > &args, CPipe::TCreateFlags create_flags, const string &current_dir, const char *const envp[], size_t pipe_size)

HANDLE x_GetHandle(CPipe::EChildIOHandle from_handle) const

EIO_Status Close(int *exitcode, const STimeout *timeout)

Callback interface for ExecWait()

Extended exit information for waited process.

T & Get(void)

Create the variable if not created yet, return the reference.

std::ofstream out("events_result.xml")

main entry point for tests

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

#define poll(fds, nfds, timeout)

void reset(element_type *p=0, EOwnership ownership=eTakeOwnership)

Reset will delete the old pointer (if owned), set content to the new value, and assume the ownership ...

CNcbiEnvironment & SetEnvironment(void)

Get a non-const copy of the application's cached environment.

static CNcbiApplicationGuard InstanceGuard(void)

Singleton method.

element_type * get(void) const

Get pointer.

@ eTakeOwnership

An object can take ownership of another.

@ eNoOwnership

No ownership is assumed.

#define ERR_POST_ONCE(message)

Error posting only once during program execution.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

const string & Get(const string &name, bool *found=NULL) const

Get environment value by name.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

void Trace(CExceptionArgs_Base &args)

virtual const char * GetErrCodeString(void) const override

Translate from the error code value to its string representation.

static string QuoteArg(const string &arg)

Quote argument.

#define NCBI_PARAM_TYPE(section, name)

Generate typename for a parameter from its {section, name} attributes.

#define NCBI_PARAM_DECL(type, section, name)

Parameter declaration.

#define NCBI_PARAM_DEF_EX(type, section, name, default_value, flags, env)

Definition of a parameter with additional flags.

@ eParam_Default

Default flags.

virtual EAction Watch(TProcessHandle)=0

This method is getting called periodically during the process execution by the ExecWait() method.

EIO_Status m_ReadStatus

Last read status.

EIO_Status Write(const void *data, size_t count, size_t *written=0)

Write data to pipe (data always goes to the child's eStdIn handle).

EIO_Status Open(const string &cmd, const vector< string > &args, TCreateFlags create_flags=0, const string &current_dir=kEmptyStr, const char *const envp[]=0, size_t pipe_size=0)

Open pipe.

EChildIOHandle m_ReadHandle

Default handle used for read.

EChildIOHandle

Which of the child I/O handles to use.

TChildPollMask Poll(TChildPollMask mask, const STimeout *timeout=0)

Wait for I/O event(s).

EFinish

ExecWait return code.

TProcessHandle GetProcessHandle(void) const

Get the process handle for the piped child.

unsigned int TChildPollMask

bitwise OR of "EChildIOHandle"

static EFinish ExecWait(const string &cmd, const vector< string > &args, CNcbiIstream &in, CNcbiOstream &out, CNcbiOstream &err, int &exit_code, const string &current_dir=kEmptyStr, const char *const envp[]=0, IProcessWatcher *watcher=0, const STimeout *kill_timeout=0, size_t pipe_size=0)

Execute a command with a vector of arguments, and wait for its completion.

void OpenSelf(void)

Open the standard streams of the current process.

EIO_Status SetReadHandle(EChildIOHandle from_handle)

Set standard output handle to read data from.

virtual EAction OnStart(TProcessHandle)

This method is called when the process has just been started by the ExecWait() method.

const STimeout * m_ReadTimeout

eIO_Read timeout

size_t m_PipeSize

Pipe size.

CPipe(size_t pipe_size=0)

Constructor.

virtual ~IProcessWatcher()

STimeout m_CloseTimeoutValue

Storage for m_CloseTimeout.

EIO_Status SetTimeout(EIO_Event event, const STimeout *timeout)

Specify timeout for the pipe I/O.

STimeout m_WriteTimeoutValue

Storage for m_WriteTimeout.

CPipeHandle * m_PipeHandle

Internal OS-specific pipe handle.

EIO_Status Read(void *buf, size_t count, size_t *read=0, EChildIOHandle from_handle=eDefault)

Read data from the pipe's default read handle.

STimeout m_ReadTimeoutValue

Storage for m_ReadTimeout.

const STimeout * m_CloseTimeout

eIO_Close timeout

unsigned int TCreateFlags

bitwise OR of "ECreateFlag"

const STimeout * GetTimeout(EIO_Event event) const

Get pipe I/O timeout.

EIO_Status CloseHandle(EChildIOHandle handle)

Close the specified child's pipe handle (even for CPipe opened with OpenSelf()).

EIO_Status m_WriteStatus

Last write status.

virtual const char * GetErrCodeString(void) const override

Translate from an error code value to its string representation.

EIO_Status Close(int *exitcode=0)

Close pipe.

const STimeout * m_WriteTimeout

eIO_Write timeout

EIO_Status Status(EIO_Event direction) const

Return a status of the last I/O operation.

@ eDefault

see SetReadHandle()

@ eDone

Process finished normally.

@ eCanceled

Watcher requested to bail out.

@ fKillOnClose

Close(): kill child process if it hasn't terminated within the allotted time.

@ fNewGroup

UNIX: new process group will be created, and the child process will become the leader of the new proc...

@ fKeepOnClose

Close(): just return eIO_Timeout if Close() cannot complete within the allotted time; don't close any...

@ fSigPipe_Restore

Restore SIGPIPE processing for child process to system default.

@ fStdErr_Open

Do open child's stderr.

@ fStdIn_Close

Do not open child's stdin.

@ fStdOut_Close

Do not open child's stdout.

@ fStdErr_Share

Keep stderr (share it with child)

@ fStdErr_StdOut

Redirect stderr to whatever stdout goes.

@ eContinue

Continue running.

@ eStop

Kill the child process and exit.

@ eExit

Exit without waiting for the child process.

bool IsPresent(void) const

TRUE if the object contains information about the process state.

bool KillGroup(unsigned long timeout=kDefaultKillTimeout) const

Terminate a group of processes.

bool IsExited(void) const

TRUE if the process terminated normally.

int GetSignal(void) const

Get the signal number that has caused the process to terminate (UNIX only).

bool Kill(unsigned long timeout=kDefaultKillTimeout)

Terminate process.

int Wait(unsigned long timeout=kInfiniteTimeoutMs, CExitInfo *info=0) const

Wait until process terminates.

static const unsigned long kDefaultKillTimeout

Default wait time (milliseconds) between "soft" and "hard" attempts to terminate a process.

pid_t TPid

Process identifier (PID) and process handle.

bool IsAlive(void) const

TRUE if the process is still alive.

bool IsSignaled(void) const

TRUE if the process terminated by a signal (UNIX only).

int GetExitCode(void) const

Get process exit code.

@ ePid

A real process identifier (pid).

@ eHandle

A process handle (MS Windows).

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define NCBI_AS_STRING(value)

Convert some value to string even if this value is macro itself.

ESwitch SOCK_SetInterruptOnSignalAPI(ESwitch on_off)

Control restartability of I/O interrupted by signals.

IO_PREFIX::ostream CNcbiOstream

Portable alias for ostream.

IO_PREFIX::istream CNcbiIstream

Portable alias for istream.

static streamsize Readsome(CNcbiIstream &is, CT_CHAR_TYPE *buf, streamsize buf_size)

static int CompareNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)

Case-insensitive compare of a substring with another string.

static const string BoolToString(bool value)

Convert bool to string.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

#define DEFINE_STATIC_FAST_MUTEX(id)

Define static fast mutex and initialize it.

const long kMicroSecondsPerSecond

Number of microseconds in one second.

unsigned long NcbiTimeoutToMs(const STimeout *timeout)

unsigned int usec

microseconds (modulo 1,000,000)

const char * IO_StatusStr(EIO_Status status)

Get the text form of an enum status value.

STimeout * NcbiMsToTimeout(STimeout *timeout, unsigned long ms)

const char * NcbiMessagePlusError(int *dynamic, const char *message, int error, const char *descr)

Add current "error" (and maybe its description) to the message: <message>[ {error=[[<error>][,...

EIO_Event

I/O event (or direction).

@ eIO_Timeout

timeout expired before any I/O succeeded

@ eIO_Interrupt

signal arrival prevented any I/O to succeed

@ eIO_Success

everything is fine, no error occurred

@ eIO_Unknown

unknown I/O error (likely fatal but can retry)

@ eIO_InvalidArg

bad argument / parameter value(s) supplied

@ eIO_ReadWrite

eIO_Read | eIO_Write (also, eCONN_OnFlush)

@ eIO_Close

also serves as an error indicator in SOCK_Poll

#define INVALID_HANDLE_VALUE

A value for an invalid file handle.

#define HANDLE

An abstraction for a file handle.

Definition of all error codes used in connect library (xconnect.lib, xconnext.lib etc).

const struct ncbi::grid::netcache::search::fields::SIZE size

static const STimeout kZeroTimeout

static string x_FormatError(int error, const string &message)

AutoPtr< char, CDeleter< char > > TTempCharPtr

static string s_FormatErrorMessage(const string &where, const string &what)

const unsigned long kWaitPrecision

static const STimeout * s_SetTimeout(const STimeout *from, STimeout *to)

#define IS_SET(flags, mask)

static string x_GetHandleName(CPipe::EChildIOHandle handle)

#define PIPE_THROW(err, errtxt)

static bool x_IsDisconnectError(DWORD error)

static string x_CommandLine(const string &cmd, const vector< string > &args)

static EIO_Status s_Close(CProcess &process, CPipe::TCreateFlags flags, const STimeout *timeout, int *exitcode)

Portable class to work with a spawned process via pipes.

Static variables safety - create on demand, destroy on application termination.

#define TRUE

bool replacment for C indicating true.

void SleepMilliSec(unsigned long ml_sec, EInterruptOnSignal onsignal=eRestartOnSignal)

Defines a portable execute class.

std::istream & in(std::istream &in_, double &x_)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4