← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/System/Unix/Program.inc

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Gran, Stephen Gran, Michael Tautschnig
  • Date: 2010-04-26 21:41:18 UTC
  • mfrom: (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100426214118-i6lo606wnh7ywfj6
Tags: 0.96+dfsg-4
http://bugs.debian.org/579271
http://bugs.debian.org/579068
[ Stephen Gran ]
* Fixed typo in clamav-milter's postinst

[ Michael Tautschnig ]
* Fixed typo in clamav-freshclam's postinst (closes: #579271)
* Debconf translation updates
  - Portuguese (closes: #579068)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/System/Unix/Program.inc
 
1
//===- llvm/System/Unix/Program.cpp -----------------------------*- C++ -*-===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file implements the Unix specific portion of the Program class.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
//===----------------------------------------------------------------------===//
 
15
//=== WARNING: Implementation here must contain only generic UNIX code that
 
16
//===          is guaranteed to work on *all* UNIX variants.
 
17
//===----------------------------------------------------------------------===//
 
18
 
 
19
#include <llvm/Config/config.h>
 
20
#include "Unix.h"
 
21
#if HAVE_SYS_STAT_H
 
22
#include <sys/stat.h>
 
23
#endif
 
24
#if HAVE_SYS_RESOURCE_H
 
25
#include <sys/resource.h>
 
26
#endif
 
27
#if HAVE_SIGNAL_H
 
28
#include <signal.h>
 
29
#endif
 
30
#if HAVE_FCNTL_H
 
31
#include <fcntl.h>
 
32
#endif
 
33
 
 
34
namespace llvm {
 
35
using namespace sys;
 
36
 
 
37
Program::Program() : Data_(0) {}
 
38
 
 
39
Program::~Program() {}
 
40
 
 
41
unsigned Program::GetPid() const {
 
42
  uint64_t pid = reinterpret_cast<uint64_t>(Data_);
 
43
  return static_cast<unsigned>(pid);
 
44
}
 
45
 
 
46
// This function just uses the PATH environment variable to find the program.
 
47
Path
 
48
Program::FindProgramByName(const std::string& progName) {
 
49
 
 
50
  // Check some degenerate cases
 
51
  if (progName.length() == 0) // no program
 
52
    return Path();
 
53
  Path temp;
 
54
  if (!temp.set(progName)) // invalid name
 
55
    return Path();
 
56
  // Use the given path verbatim if it contains any slashes; this matches
 
57
  // the behavior of sh(1) and friends.
 
58
  if (progName.find('/') != std::string::npos)
 
59
    return temp;
 
60
 
 
61
  // At this point, the file name does not contain slashes. Search for it
 
62
  // through the directories specified in the PATH environment variable.
 
63
 
 
64
  // Get the path. If its empty, we can't do anything to find it.
 
65
  const char *PathStr = getenv("PATH");
 
66
  if (PathStr == 0)
 
67
    return Path();
 
68
 
 
69
  // Now we have a colon separated list of directories to search; try them.
 
70
  size_t PathLen = strlen(PathStr);
 
71
  while (PathLen) {
 
72
    // Find the first colon...
 
73
    const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
 
74
 
 
75
    // Check to see if this first directory contains the executable...
 
76
    Path FilePath;
 
77
    if (FilePath.set(std::string(PathStr,Colon))) {
 
78
      FilePath.appendComponent(progName);
 
79
      if (FilePath.canExecute())
 
80
        return FilePath;                    // Found the executable!
 
81
    }
 
82
 
 
83
    // Nope it wasn't in this directory, check the next path in the list!
 
84
    PathLen -= Colon-PathStr;
 
85
    PathStr = Colon;
 
86
 
 
87
    // Advance past duplicate colons
 
88
    while (*PathStr == ':') {
 
89
      PathStr++;
 
90
      PathLen--;
 
91
    }
 
92
  }
 
93
  return Path();
 
94
}
 
95
 
 
96
static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
 
97
  if (Path == 0)
 
98
    // Noop
 
99
    return false;
 
100
  std::string File;
 
101
  if (Path->isEmpty())
 
102
    // Redirect empty paths to /dev/null
 
103
    File = "/dev/null";
 
104
  else
 
105
    File = Path->str();
 
106
 
 
107
  // Open the file
 
108
  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
 
109
  if (InFD == -1) {
 
110
    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
 
111
              + (FD == 0 ? "input" : "output"));
 
112
    return true;
 
113
  }
 
114
 
 
115
  // Install it as the requested FD
 
116
  if (-1 == dup2(InFD, FD)) {
 
117
    MakeErrMsg(ErrMsg, "Cannot dup2");
 
118
    return true;
 
119
  }
 
120
  close(InFD);      // Close the original FD
 
121
  return false;
 
122
}
 
123
 
 
124
static void TimeOutHandler(int Sig) {
 
125
}
 
126
 
 
127
static void SetMemoryLimits (unsigned size)
 
128
{
 
129
#if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
 
130
  struct rlimit r;
 
131
  __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576;
 
132
 
 
133
  // Heap size
 
134
  getrlimit (RLIMIT_DATA, &r);
 
135
  r.rlim_cur = limit;
 
136
  setrlimit (RLIMIT_DATA, &r);
 
137
#ifdef RLIMIT_RSS
 
138
  // Resident set size.
 
139
  getrlimit (RLIMIT_RSS, &r);
 
140
  r.rlim_cur = limit;
 
141
  setrlimit (RLIMIT_RSS, &r);
 
142
#endif
 
143
#ifdef RLIMIT_AS  // e.g. NetBSD doesn't have it.
 
144
  // Virtual memory.
 
145
  getrlimit (RLIMIT_AS, &r);
 
146
  r.rlim_cur = limit;
 
147
  setrlimit (RLIMIT_AS, &r);
 
148
#endif
 
149
#endif
 
150
}
 
151
 
 
152
bool
 
153
Program::Execute(const Path& path,
 
154
                 const char** args,
 
155
                 const char** envp,
 
156
                 const Path** redirects,
 
157
                 unsigned memoryLimit,
 
158
                 std::string* ErrMsg)
 
159
{
 
160
  if (!path.canExecute()) {
 
161
    if (ErrMsg)
 
162
      *ErrMsg = path.str() + " is not executable";
 
163
    return false;
 
164
  }
 
165
 
 
166
  // Create a child process.
 
167
  int child = fork();
 
168
  switch (child) {
 
169
    // An error occured:  Return to the caller.
 
170
    case -1:
 
171
      MakeErrMsg(ErrMsg, "Couldn't fork");
 
172
      return false;
 
173
 
 
174
    // Child process: Execute the program.
 
175
    case 0: {
 
176
      // Redirect file descriptors...
 
177
      if (redirects) {
 
178
        // Redirect stdin
 
179
        if (RedirectIO(redirects[0], 0, ErrMsg)) { return false; }
 
180
        // Redirect stdout
 
181
        if (RedirectIO(redirects[1], 1, ErrMsg)) { return false; }
 
182
        if (redirects[1] && redirects[2] &&
 
183
            *(redirects[1]) == *(redirects[2])) {
 
184
          // If stdout and stderr should go to the same place, redirect stderr
 
185
          // to the FD already open for stdout.
 
186
          if (-1 == dup2(1,2)) {
 
187
            MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
 
188
            return false;
 
189
          }
 
190
        } else {
 
191
          // Just redirect stderr
 
192
          if (RedirectIO(redirects[2], 2, ErrMsg)) { return false; }
 
193
        }
 
194
      }
 
195
 
 
196
      // Set memory limits
 
197
      if (memoryLimit!=0) {
 
198
        SetMemoryLimits(memoryLimit);
 
199
      }
 
200
 
 
201
      // Execute!
 
202
      if (envp != 0)
 
203
        execve(path.c_str(), (char**)args, (char**)envp);
 
204
      else
 
205
        execv(path.c_str(), (char**)args);
 
206
      // If the execve() failed, we should exit. Follow Unix protocol and
 
207
      // return 127 if the executable was not found, and 126 otherwise.
 
208
      // Use _exit rather than exit so that atexit functions and static
 
209
      // object destructors cloned from the parent process aren't
 
210
      // redundantly run, and so that any data buffered in stdio buffers
 
211
      // cloned from the parent aren't redundantly written out.
 
212
      _exit(errno == ENOENT ? 127 : 126);
 
213
    }
 
214
 
 
215
    // Parent process: Break out of the switch to do our processing.
 
216
    default:
 
217
      break;
 
218
  }
 
219
 
 
220
  Data_ = reinterpret_cast<void*>(child);
 
221
 
 
222
  return true;
 
223
}
 
224
 
 
225
int
 
226
Program::Wait(unsigned secondsToWait,
 
227
              std::string* ErrMsg)
 
228
{
 
229
#ifdef HAVE_SYS_WAIT_H
 
230
  struct sigaction Act, Old;
 
231
 
 
232
  if (Data_ == 0) {
 
233
    MakeErrMsg(ErrMsg, "Process not started!");
 
234
    return -1;
 
235
  }
 
236
 
 
237
  // Install a timeout handler.  The handler itself does nothing, but the simple
 
238
  // fact of having a handler at all causes the wait below to return with EINTR,
 
239
  // unlike if we used SIG_IGN.
 
240
  if (secondsToWait) {
 
241
    Act.sa_sigaction = 0;
 
242
    Act.sa_handler = TimeOutHandler;
 
243
    sigemptyset(&Act.sa_mask);
 
244
    Act.sa_flags = 0;
 
245
    sigaction(SIGALRM, &Act, &Old);
 
246
    alarm(secondsToWait);
 
247
  }
 
248
 
 
249
  // Parent process: Wait for the child process to terminate.
 
250
  int status;
 
251
  uint64_t pid = reinterpret_cast<uint64_t>(Data_);
 
252
  pid_t child = static_cast<pid_t>(pid);
 
253
  while (waitpid(pid, &status, 0) != child)
 
254
    if (secondsToWait && errno == EINTR) {
 
255
      // Kill the child.
 
256
      kill(child, SIGKILL);
 
257
 
 
258
      // Turn off the alarm and restore the signal handler
 
259
      alarm(0);
 
260
      sigaction(SIGALRM, &Old, 0);
 
261
 
 
262
      // Wait for child to die
 
263
      if (wait(&status) != child)
 
264
        MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
 
265
      else
 
266
        MakeErrMsg(ErrMsg, "Child timed out", 0);
 
267
 
 
268
      return -1;   // Timeout detected
 
269
    } else if (errno != EINTR) {
 
270
      MakeErrMsg(ErrMsg, "Error waiting for child process");
 
271
      return -1;
 
272
    }
 
273
 
 
274
  // We exited normally without timeout, so turn off the timer.
 
275
  if (secondsToWait) {
 
276
    alarm(0);
 
277
    sigaction(SIGALRM, &Old, 0);
 
278
  }
 
279
 
 
280
  // Return the proper exit status. 0=success, >0 is programs' exit status,
 
281
  // <0 means a signal was returned, -9999999 means the program dumped core.
 
282
  int result = 0;
 
283
  if (WIFEXITED(status))
 
284
    result = WEXITSTATUS(status);
 
285
  else if (WIFSIGNALED(status))
 
286
    result = 0 - WTERMSIG(status);
 
287
#ifdef WCOREDUMP
 
288
  else if (WCOREDUMP(status))
 
289
    result |= 0x01000000;
 
290
#endif
 
291
  return result;
 
292
#else
 
293
  return -99;
 
294
#endif
 
295
 
 
296
}
 
297
 
 
298
bool
 
299
Program::Kill(std::string* ErrMsg) {
 
300
  if (Data_ == 0) {
 
301
    MakeErrMsg(ErrMsg, "Process not started!");
 
302
    return true;
 
303
  }
 
304
 
 
305
  uint64_t pid64 = reinterpret_cast<uint64_t>(Data_);
 
306
  pid_t pid = static_cast<pid_t>(pid64);
 
307
 
 
308
  if (kill(pid, SIGKILL) != 0) {
 
309
    MakeErrMsg(ErrMsg, "The process couldn't be killed!");
 
310
    return true;
 
311
  }
 
312
 
 
313
  return false;
 
314
}
 
315
 
 
316
bool Program::ChangeStdinToBinary(){
 
317
  // Do nothing, as Unix doesn't differentiate between text and binary.
 
318
  return false;
 
319
}
 
320
 
 
321
bool Program::ChangeStdoutToBinary(){
 
322
  // Do nothing, as Unix doesn't differentiate between text and binary.
 
323
  return false;
 
324
}
 
325
 
 
326
bool Program::ChangeStderrToBinary(){
 
327
  // Do nothing, as Unix doesn't differentiate between text and binary.
 
328
  return false;
 
329
}
 
330
 
 
331
}