← Back to branch summary

~ubuntu-branches/ubuntu/utopic/coreutils/utopic-proposed

« back to all changes in this revision

Viewing changes to m4/posix_spawn.m4

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-11-28 03:03:42 UTC
  • mfrom: (8.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20121128030342-21zanj8354gas5gr
Tags: 8.20-3ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - Make 'uname -i -p' return the real processor/hardware, instead of
    unknown.
  - Build-depend on gettext:any instead of on gettext, so that apt-get can
    properly resolve build-dependencies on the tool when cross-building.

Show diffs side-by-side

added added

removed removed

Lines of Context:
m4/posix_spawn.m4
 
1
# posix_spawn.m4 serial 11
 
2
dnl Copyright (C) 2008-2012 Free Software Foundation, Inc.
 
3
dnl This file is free software; the Free Software Foundation
 
4
dnl gives unlimited permission to copy and/or distribute it,
 
5
dnl with or without modifications, as long as this notice is preserved.
 
6
 
 
7
dnl Tests whether the entire posix_spawn facility is available.
 
8
AC_DEFUN([gl_POSIX_SPAWN],
 
9
[
 
10
  AC_REQUIRE([gl_POSIX_SPAWN_BODY])
 
11
])
 
12
 
 
13
AC_DEFUN([gl_POSIX_SPAWN_BODY],
 
14
[
 
15
  AC_REQUIRE([gl_SPAWN_H_DEFAULTS])
 
16
  AC_REQUIRE([gl_HAVE_POSIX_SPAWN])
 
17
  dnl Assume that when the main function exists, all the others,
 
18
  dnl except posix_spawnattr_{get,set}sched*, are available as well.
 
19
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnp])
 
20
  dnl AC_CHECK_FUNCS_ONCE([posix_spawn_file_actions_init])
 
21
  dnl AC_CHECK_FUNCS_ONCE([posix_spawn_file_actions_addclose])
 
22
  dnl AC_CHECK_FUNCS_ONCE([posix_spawn_file_actions_adddup2])
 
23
  dnl AC_CHECK_FUNCS_ONCE([posix_spawn_file_actions_addopen])
 
24
  dnl AC_CHECK_FUNCS_ONCE([posix_spawn_file_actions_destroy])
 
25
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_init])
 
26
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getflags])
 
27
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setflags])
 
28
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getpgroup])
 
29
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setpgroup])
 
30
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getsigdefault])
 
31
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setsigdefault])
 
32
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getsigmask])
 
33
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setsigmask])
 
34
  dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_destroy])
 
35
  if test $ac_cv_func_posix_spawn = yes; then
 
36
    gl_POSIX_SPAWN_WORKS
 
37
    case "$gl_cv_func_posix_spawn_works" in
 
38
      *yes)
 
39
        AC_DEFINE([HAVE_WORKING_POSIX_SPAWN], [1],
 
40
          [Define if you have the posix_spawn and posix_spawnp functions and
 
41
           they work.])
 
42
        dnl Assume that these functions are available if POSIX_SPAWN_SETSCHEDULER
 
43
        dnl evaluates to nonzero.
 
44
        dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getschedpolicy])
 
45
        dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setschedpolicy])
 
46
        AC_CACHE_CHECK([whether posix_spawnattr_setschedpolicy is supported],
 
47
          [gl_cv_func_spawnattr_setschedpolicy],
 
48
          [AC_EGREP_CPP([POSIX scheduling supported], [
 
49
#include <spawn.h>
 
50
#if POSIX_SPAWN_SETSCHEDULER
 
51
 POSIX scheduling supported
 
52
#endif
 
53
],
 
54
             [gl_cv_func_spawnattr_setschedpolicy=yes],
 
55
             [gl_cv_func_spawnattr_setschedpolicy=no])
 
56
          ])
 
57
        dnl Assume that these functions are available if POSIX_SPAWN_SETSCHEDPARAM
 
58
        dnl evaluates to nonzero.
 
59
        dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_getschedparam])
 
60
        dnl AC_CHECK_FUNCS_ONCE([posix_spawnattr_setschedparam])
 
61
        AC_CACHE_CHECK([whether posix_spawnattr_setschedparam is supported],
 
62
          [gl_cv_func_spawnattr_setschedparam],
 
63
          [AC_EGREP_CPP([POSIX scheduling supported], [
 
64
#include <spawn.h>
 
65
#if POSIX_SPAWN_SETSCHEDPARAM
 
66
 POSIX scheduling supported
 
67
#endif
 
68
],
 
69
             [gl_cv_func_spawnattr_setschedparam=yes],
 
70
             [gl_cv_func_spawnattr_setschedparam=no])
 
71
          ])
 
72
        ;;
 
73
      *) REPLACE_POSIX_SPAWN=1 ;;
 
74
    esac
 
75
  fi
 
76
])
 
77
 
 
78
dnl Test whether posix_spawn actually works.
 
79
dnl posix_spawn on AIX 5.3..6.1 has two bugs:
 
80
dnl 1) When it fails to execute the program, the child process exits with
 
81
dnl    exit() rather than _exit(), which causes the stdio buffers to be
 
82
dnl    flushed. Reported by Rainer Tammer.
 
83
dnl 2) The posix_spawn_file_actions_addopen function does not support file
 
84
dnl    names that contain a '*'.
 
85
dnl posix_spawn on AIX 5.3..6.1 has also a third bug: It does not work
 
86
dnl when POSIX threads are used. But we don't test against this bug here.
 
87
AC_DEFUN([gl_POSIX_SPAWN_WORKS],
 
88
[
 
89
  AC_REQUIRE([AC_PROG_CC])
 
90
  AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 
91
  AC_CACHE_CHECK([whether posix_spawn works], [gl_cv_func_posix_spawn_works],
 
92
    [if test $cross_compiling = no; then
 
93
       AC_LINK_IFELSE([AC_LANG_SOURCE([[
 
94
#include <errno.h>
 
95
#include <fcntl.h>
 
96
#include <signal.h>
 
97
#include <spawn.h>
 
98
#include <stdbool.h>
 
99
#include <stdio.h>
 
100
#include <stdlib.h>
 
101
#include <string.h>
 
102
#include <unistd.h>
 
103
#include <sys/types.h>
 
104
#include <sys/wait.h>
 
105
 
 
106
extern char **environ;
 
107
 
 
108
#ifndef STDIN_FILENO
 
109
# define STDIN_FILENO 0
 
110
#endif
 
111
#ifndef STDOUT_FILENO
 
112
# define STDOUT_FILENO 1
 
113
#endif
 
114
#ifndef STDERR_FILENO
 
115
# define STDERR_FILENO 2
 
116
#endif
 
117
 
 
118
#ifndef WTERMSIG
 
119
# define WTERMSIG(x) ((x) & 0x7f)
 
120
#endif
 
121
#ifndef WIFEXITED
 
122
# define WIFEXITED(x) (WTERMSIG (x) == 0)
 
123
#endif
 
124
#ifndef WEXITSTATUS
 
125
# define WEXITSTATUS(x) (((x) >> 8) & 0xff)
 
126
#endif
 
127
 
 
128
#define CHILD_PROGRAM_FILENAME "/non/exist/ent"
 
129
 
 
130
static int
 
131
fd_safer (int fd)
 
132
{
 
133
  if (0 <= fd && fd <= 2)
 
134
    {
 
135
      int f = fd_safer (dup (fd));
 
136
      int e = errno;
 
137
      close (fd);
 
138
      errno = e;
 
139
      fd = f;
 
140
    }
 
141
 
 
142
  return fd;
 
143
}
 
144
 
 
145
int
 
146
main ()
 
147
{
 
148
  char *argv[2] = { CHILD_PROGRAM_FILENAME, NULL };
 
149
  int ofd[2];
 
150
  sigset_t blocked_signals;
 
151
  sigset_t fatal_signal_set;
 
152
  posix_spawn_file_actions_t actions;
 
153
  bool actions_allocated;
 
154
  posix_spawnattr_t attrs;
 
155
  bool attrs_allocated;
 
156
  int err;
 
157
  pid_t child;
 
158
  int status;
 
159
  int exitstatus;
 
160
 
 
161
  setvbuf (stdout, NULL, _IOFBF, 0);
 
162
  puts ("This should be seen only once.");
 
163
  if (pipe (ofd) < 0 || (ofd[1] = fd_safer (ofd[1])) < 0)
 
164
    {
 
165
      perror ("cannot create pipe");
 
166
      exit (1);
 
167
    }
 
168
  sigprocmask (SIG_SETMASK, NULL, &blocked_signals);
 
169
  sigemptyset (&fatal_signal_set);
 
170
  sigaddset (&fatal_signal_set, SIGINT);
 
171
  sigaddset (&fatal_signal_set, SIGTERM);
 
172
  sigaddset (&fatal_signal_set, SIGHUP);
 
173
  sigaddset (&fatal_signal_set, SIGPIPE);
 
174
  sigprocmask (SIG_BLOCK, &fatal_signal_set, NULL);
 
175
  actions_allocated = false;
 
176
  attrs_allocated = false;
 
177
  if ((err = posix_spawn_file_actions_init (&actions)) != 0
 
178
      || (actions_allocated = true,
 
179
          (err = posix_spawn_file_actions_adddup2 (&actions, ofd[0], STDIN_FILENO)) != 0
 
180
          || (err = posix_spawn_file_actions_addclose (&actions, ofd[0])) != 0
 
181
          || (err = posix_spawn_file_actions_addclose (&actions, ofd[1])) != 0
 
182
          || (err = posix_spawnattr_init (&attrs)) != 0
 
183
          || (attrs_allocated = true,
 
184
              (err = posix_spawnattr_setsigmask (&attrs, &blocked_signals)) != 0
 
185
              || (err = posix_spawnattr_setflags (&attrs, POSIX_SPAWN_SETSIGMASK)) != 0)
 
186
          || (err = posix_spawnp (&child, CHILD_PROGRAM_FILENAME, &actions, &attrs, argv, environ)) != 0))
 
187
    {
 
188
      if (actions_allocated)
 
189
        posix_spawn_file_actions_destroy (&actions);
 
190
      if (attrs_allocated)
 
191
        posix_spawnattr_destroy (&attrs);
 
192
      sigprocmask (SIG_UNBLOCK, &fatal_signal_set, NULL);
 
193
      if (err == ENOENT)
 
194
        return 0;
 
195
      else
 
196
        {
 
197
          errno = err;
 
198
          perror ("subprocess failed");
 
199
          exit (1);
 
200
        }
 
201
    }
 
202
  posix_spawn_file_actions_destroy (&actions);
 
203
  posix_spawnattr_destroy (&attrs);
 
204
  sigprocmask (SIG_UNBLOCK, &fatal_signal_set, NULL);
 
205
  close (ofd[0]);
 
206
  close (ofd[1]);
 
207
  status = 0;
 
208
  while (waitpid (child, &status, 0) != child)
 
209
    ;
 
210
  if (!WIFEXITED (status))
 
211
    {
 
212
      fprintf (stderr, "subprocess terminated with unexpected wait status %d\n", status);
 
213
      exit (1);
 
214
    }
 
215
  exitstatus = WEXITSTATUS (status);
 
216
  if (exitstatus != 127)
 
217
    {
 
218
      fprintf (stderr, "subprocess terminated with unexpected exit status %d\n", exitstatus);
 
219
      exit (1);
 
220
    }
 
221
  return 0;
 
222
}
 
223
]])],
 
224
         [if test -s conftest$ac_exeext \
 
225
             && ./conftest$ac_exeext > conftest.out \
 
226
             && echo 'This should be seen only once.' > conftest.ok \
 
227
             && cmp conftest.out conftest.ok > /dev/null; then
 
228
            gl_cv_func_posix_spawn_works=yes
 
229
          else
 
230
            gl_cv_func_posix_spawn_works=no
 
231
          fi],
 
232
         [gl_cv_func_posix_spawn_works=no])
 
233
       if test $gl_cv_func_posix_spawn_works = yes; then
 
234
         AC_RUN_IFELSE([AC_LANG_SOURCE([[
 
235
/* Test whether posix_spawn_file_actions_addopen supports filename arguments
 
236
   that contain special characters such as '*'.  */
 
237
 
 
238
#include <errno.h>
 
239
#include <fcntl.h>
 
240
#include <signal.h>
 
241
#include <spawn.h>
 
242
#include <stdbool.h>
 
243
#include <stdio.h>
 
244
#include <string.h>
 
245
#include <unistd.h>
 
246
#include <sys/types.h>
 
247
#include <sys/wait.h>
 
248
 
 
249
extern char **environ;
 
250
 
 
251
#ifndef STDIN_FILENO
 
252
# define STDIN_FILENO 0
 
253
#endif
 
254
#ifndef STDOUT_FILENO
 
255
# define STDOUT_FILENO 1
 
256
#endif
 
257
#ifndef STDERR_FILENO
 
258
# define STDERR_FILENO 2
 
259
#endif
 
260
 
 
261
#ifndef WTERMSIG
 
262
# define WTERMSIG(x) ((x) & 0x7f)
 
263
#endif
 
264
#ifndef WIFEXITED
 
265
# define WIFEXITED(x) (WTERMSIG (x) == 0)
 
266
#endif
 
267
#ifndef WEXITSTATUS
 
268
# define WEXITSTATUS(x) (((x) >> 8) & 0xff)
 
269
#endif
 
270
 
 
271
#define CHILD_PROGRAM_FILENAME "conftest"
 
272
#define DATA_FILENAME "conftest%=*#?"
 
273
 
 
274
static int
 
275
parent_main (void)
 
276
{
 
277
  FILE *fp;
 
278
  char *argv[3] = { CHILD_PROGRAM_FILENAME, "-child", NULL };
 
279
  posix_spawn_file_actions_t actions;
 
280
  bool actions_allocated;
 
281
  int err;
 
282
  pid_t child;
 
283
  int status;
 
284
  int exitstatus;
 
285
 
 
286
  /* Create a data file with specific contents.  */
 
287
  fp = fopen (DATA_FILENAME, "wb");
 
288
  if (fp == NULL)
 
289
    {
 
290
      perror ("cannot create data file");
 
291
      return 1;
 
292
    }
 
293
  fwrite ("Halle Potta", 1, 11, fp);
 
294
  if (fflush (fp) || fclose (fp))
 
295
    {
 
296
      perror ("cannot prepare data file");
 
297
      return 2;
 
298
    }
 
299
 
 
300
  /* Avoid reading from our stdin, as it could block.  */
 
301
  freopen ("/dev/null", "rb", stdin);
 
302
 
 
303
  /* Test whether posix_spawn_file_actions_addopen with this file name
 
304
     actually works, but spawning a child that reads from this file.  */
 
305
  actions_allocated = false;
 
306
  if ((err = posix_spawn_file_actions_init (&actions)) != 0
 
307
      || (actions_allocated = true,
 
308
          (err = posix_spawn_file_actions_addopen (&actions, STDIN_FILENO, DATA_FILENAME, O_RDONLY, 0600)) != 0
 
309
          || (err = posix_spawn (&child, CHILD_PROGRAM_FILENAME, &actions, NULL, argv, environ)) != 0))
 
310
    {
 
311
      if (actions_allocated)
 
312
        posix_spawn_file_actions_destroy (&actions);
 
313
      errno = err;
 
314
      perror ("subprocess failed");
 
315
      return 3;
 
316
    }
 
317
  posix_spawn_file_actions_destroy (&actions);
 
318
  status = 0;
 
319
  while (waitpid (child, &status, 0) != child)
 
320
    ;
 
321
  if (!WIFEXITED (status))
 
322
    {
 
323
      fprintf (stderr, "subprocess terminated with unexpected wait status %d\n", status);
 
324
      return 4;
 
325
    }
 
326
  exitstatus = WEXITSTATUS (status);
 
327
  if (exitstatus != 0)
 
328
    {
 
329
      fprintf (stderr, "subprocess terminated with unexpected exit status %d\n", exitstatus);
 
330
      return 5;
 
331
    }
 
332
  return 0;
 
333
}
 
334
 
 
335
static int
 
336
child_main (void)
 
337
{
 
338
  char buf[1024];
 
339
 
 
340
  /* See if reading from STDIN_FILENO yields the expected contents.  */
 
341
  if (fread (buf, 1, sizeof (buf), stdin) == 11
 
342
      && memcmp (buf, "Halle Potta", 11) == 0)
 
343
    return 0;
 
344
  else
 
345
    return 8;
 
346
}
 
347
 
 
348
static void
 
349
cleanup_then_die (int sig)
 
350
{
 
351
  /* Clean up data file.  */
 
352
  unlink (DATA_FILENAME);
 
353
 
 
354
  /* Re-raise the signal and die from it.  */
 
355
  signal (sig, SIG_DFL);
 
356
  raise (sig);
 
357
}
 
358
 
 
359
int
 
360
main (int argc, char *argv[])
 
361
{
 
362
  int exitstatus;
 
363
 
 
364
  if (!(argc > 1 && strcmp (argv[1], "-child") == 0))
 
365
    {
 
366
      /* This is the parent process.  */
 
367
      signal (SIGINT, cleanup_then_die);
 
368
      signal (SIGTERM, cleanup_then_die);
 
369
      #ifdef SIGHUP
 
370
      signal (SIGHUP, cleanup_then_die);
 
371
      #endif
 
372
 
 
373
      exitstatus = parent_main ();
 
374
    }
 
375
  else
 
376
    {
 
377
      /* This is the child process.  */
 
378
 
 
379
      exitstatus = child_main ();
 
380
    }
 
381
  unlink (DATA_FILENAME);
 
382
  return exitstatus;
 
383
}
 
384
]])],
 
385
           [],
 
386
           [gl_cv_func_posix_spawn_works=no])
 
387
       fi
 
388
     else
 
389
       case "$host_os" in
 
390
         aix*) gl_cv_func_posix_spawn_works="guessing no";;
 
391
         *)    gl_cv_func_posix_spawn_works="guessing yes";;
 
392
       esac
 
393
     fi
 
394
    ])
 
395
])
 
396
 
 
397
# Prerequisites of lib/spawni.c.
 
398
AC_DEFUN([gl_PREREQ_POSIX_SPAWN_INTERNAL],
 
399
[
 
400
  AC_CHECK_HEADERS([paths.h])
 
401
  AC_CHECK_FUNCS([confstr sched_setparam sched_setscheduler setegid seteuid vfork])
 
402
])
 
403
 
 
404
AC_DEFUN([gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE],
 
405
[
 
406
  AC_REQUIRE([gl_SPAWN_H_DEFAULTS])
 
407
  AC_REQUIRE([AC_PROG_CC])
 
408
  AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 
409
  gl_POSIX_SPAWN
 
410
  if test $REPLACE_POSIX_SPAWN = 1; then
 
411
    REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE=1
 
412
  else
 
413
    dnl On Solaris 11 2011-11, posix_spawn_file_actions_addclose succeeds even
 
414
    dnl if the fd argument is out of range.
 
415
    AC_CACHE_CHECK([whether posix_spawn_file_actions_addclose works],
 
416
      [gl_cv_func_posix_spawn_file_actions_addclose_works],
 
417
      [AC_RUN_IFELSE(
 
418
         [AC_LANG_SOURCE([[
 
419
#include <spawn.h>
 
420
int main ()
 
421
{
 
422
  posix_spawn_file_actions_t actions;
 
423
  if (posix_spawn_file_actions_init (&actions) != 0)
 
424
    return 1;
 
425
  if (posix_spawn_file_actions_addclose (&actions, 10000000) == 0)
 
426
    return 2;
 
427
  return 0;
 
428
}]])],
 
429
         [gl_cv_func_posix_spawn_file_actions_addclose_works=yes],
 
430
         [gl_cv_func_posix_spawn_file_actions_addclose_works=no],
 
431
         [# Guess no on Solaris, yes otherwise.
 
432
          case "$host_os" in
 
433
            solaris*) gl_cv_func_posix_spawn_file_actions_addclose_works="guessing no";;
 
434
            *)        gl_cv_func_posix_spawn_file_actions_addclose_works="guessing yes";;
 
435
          esac
 
436
         ])
 
437
      ])
 
438
    case "$gl_cv_func_posix_spawn_file_actions_addclose_works" in
 
439
      *yes) ;;
 
440
      *) REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE=1 ;;
 
441
    esac
 
442
  fi
 
443
])
 
444
 
 
445
AC_DEFUN([gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2],
 
446
[
 
447
  AC_REQUIRE([gl_SPAWN_H_DEFAULTS])
 
448
  AC_REQUIRE([AC_PROG_CC])
 
449
  AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 
450
  gl_POSIX_SPAWN
 
451
  if test $REPLACE_POSIX_SPAWN = 1; then
 
452
    REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2=1
 
453
  else
 
454
    dnl On Solaris 11 2011-11, posix_spawn_file_actions_adddup2 succeeds even
 
455
    dnl if the fd argument is out of range.
 
456
    AC_CACHE_CHECK([whether posix_spawn_file_actions_adddup2 works],
 
457
      [gl_cv_func_posix_spawn_file_actions_adddup2_works],
 
458
      [AC_RUN_IFELSE(
 
459
         [AC_LANG_SOURCE([[
 
460
#include <spawn.h>
 
461
int main ()
 
462
{
 
463
  posix_spawn_file_actions_t actions;
 
464
  if (posix_spawn_file_actions_init (&actions) != 0)
 
465
    return 1;
 
466
  if (posix_spawn_file_actions_adddup2 (&actions, 10000000, 2) == 0)
 
467
    return 2;
 
468
  return 0;
 
469
}]])],
 
470
         [gl_cv_func_posix_spawn_file_actions_adddup2_works=yes],
 
471
         [gl_cv_func_posix_spawn_file_actions_adddup2_works=no],
 
472
         [# Guess no on Solaris, yes otherwise.
 
473
          case "$host_os" in
 
474
            solaris*) gl_cv_func_posix_spawn_file_actions_adddup2_works="guessing no";;
 
475
            *)        gl_cv_func_posix_spawn_file_actions_adddup2_works="guessing yes";;
 
476
          esac
 
477
         ])
 
478
      ])
 
479
    case "$gl_cv_func_posix_spawn_file_actions_adddup2_works" in
 
480
      *yes) ;;
 
481
      *) REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2=1 ;;
 
482
    esac
 
483
  fi
 
484
])
 
485
 
 
486
AC_DEFUN([gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN],
 
487
[
 
488
  AC_REQUIRE([gl_SPAWN_H_DEFAULTS])
 
489
  AC_REQUIRE([AC_PROG_CC])
 
490
  AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 
491
  gl_POSIX_SPAWN
 
492
  if test $REPLACE_POSIX_SPAWN = 1; then
 
493
    REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN=1
 
494
  else
 
495
    dnl On Solaris 11 2011-11, posix_spawn_file_actions_addopen succeeds even
 
496
    dnl if the fd argument is out of range.
 
497
    AC_CACHE_CHECK([whether posix_spawn_file_actions_addopen works],
 
498
      [gl_cv_func_posix_spawn_file_actions_addopen_works],
 
499
      [AC_RUN_IFELSE(
 
500
         [AC_LANG_SOURCE([[
 
501
#include <spawn.h>
 
502
#include <fcntl.h>
 
503
int main ()
 
504
{
 
505
  posix_spawn_file_actions_t actions;
 
506
  if (posix_spawn_file_actions_init (&actions) != 0)
 
507
    return 1;
 
508
  if (posix_spawn_file_actions_addopen (&actions, 10000000, "foo", 0, O_RDONLY)
 
509
      == 0)
 
510
    return 2;
 
511
  return 0;
 
512
}]])],
 
513
         [gl_cv_func_posix_spawn_file_actions_addopen_works=yes],
 
514
         [gl_cv_func_posix_spawn_file_actions_addopen_works=no],
 
515
         [# Guess no on Solaris, yes otherwise.
 
516
          case "$host_os" in
 
517
            solaris*) gl_cv_func_posix_spawn_file_actions_addopen_works="guessing no";;
 
518
            *)        gl_cv_func_posix_spawn_file_actions_addopen_works="guessing yes";;
 
519
          esac
 
520
         ])
 
521
      ])
 
522
    case "$gl_cv_func_posix_spawn_file_actions_addopen_works" in
 
523
      *yes) ;;
 
524
      *) REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN=1 ;;
 
525
    esac
 
526
  fi
 
527
])