Annotation of embedaddon/php/sapi/fpm/config.m4, revision 1.1.1.2

1.1       misho       1: dnl
                      2: dnl $Id$
                      3: dnl
                      4: 
                      5: PHP_ARG_ENABLE(fpm,,
1.1.1.2 ! misho       6: [  --enable-fpm              Enable building of the fpm SAPI executable], no, no)
1.1       misho       7: 
                      8: dnl configure checks {{{
                      9: AC_DEFUN([AC_FPM_STDLIBS],
                     10: [
                     11:   AC_CHECK_FUNCS(setenv clearenv setproctitle)
                     12: 
                     13:   AC_SEARCH_LIBS(socket, socket)
                     14:   AC_SEARCH_LIBS(inet_addr, nsl)
                     15: 
                     16:   AC_CHECK_HEADERS([errno.h fcntl.h stdio.h stdlib.h unistd.h sys/uio.h])
                     17:   AC_CHECK_HEADERS([sys/select.h sys/socket.h sys/time.h])
                     18:   AC_CHECK_HEADERS([arpa/inet.h netinet/in.h])
                     19: ])
                     20: 
                     21: AC_DEFUN([AC_FPM_PRCTL],
                     22: [
                     23:   AC_MSG_CHECKING([for prctl])
                     24: 
                     25:   AC_TRY_COMPILE([ #include <sys/prctl.h> ], [prctl(0, 0, 0, 0, 0);], [
                     26:     AC_DEFINE([HAVE_PRCTL], 1, [do we have prctl?])
                     27:     AC_MSG_RESULT([yes])
                     28:   ], [
                     29:     AC_MSG_RESULT([no])
                     30:   ])
                     31: ])
                     32: 
                     33: AC_DEFUN([AC_FPM_CLOCK],
                     34: [
                     35:   have_clock_gettime=no
                     36: 
                     37:   AC_MSG_CHECKING([for clock_gettime])
                     38: 
                     39:   AC_TRY_LINK([ #include <time.h> ], [struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);], [
                     40:     have_clock_gettime=yes
                     41:     AC_MSG_RESULT([yes])
                     42:   ], [
                     43:     AC_MSG_RESULT([no])
                     44:   ])
                     45: 
                     46:   if test "$have_clock_gettime" = "no"; then
                     47:     AC_MSG_CHECKING([for clock_gettime in -lrt])
                     48: 
                     49:     SAVED_LIBS="$LIBS"
                     50:     LIBS="$LIBS -lrt"
                     51: 
                     52:     AC_TRY_LINK([ #include <time.h> ], [struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);], [
                     53:       have_clock_gettime=yes
                     54:       AC_MSG_RESULT([yes])
                     55:     ], [
                     56:       LIBS="$SAVED_LIBS"
                     57:       AC_MSG_RESULT([no])
                     58:     ])
                     59:   fi
                     60: 
                     61:   if test "$have_clock_gettime" = "yes"; then
                     62:     AC_DEFINE([HAVE_CLOCK_GETTIME], 1, [do we have clock_gettime?])
                     63:   fi
                     64: 
                     65:   have_clock_get_time=no
                     66: 
                     67:   if test "$have_clock_gettime" = "no"; then
                     68:     AC_MSG_CHECKING([for clock_get_time])
                     69: 
                     70:     AC_TRY_RUN([ #include <mach/mach.h>
                     71:       #include <mach/clock.h>
                     72:       #include <mach/mach_error.h>
                     73: 
                     74:       int main()
                     75:       {
                     76:         kern_return_t ret; clock_serv_t aClock; mach_timespec_t aTime;
                     77:         ret = host_get_clock_service(mach_host_self(), REALTIME_CLOCK, &aClock);
                     78: 
                     79:         if (ret != KERN_SUCCESS) {
                     80:           return 1;
                     81:         }
                     82: 
                     83:         ret = clock_get_time(aClock, &aTime);
                     84:         if (ret != KERN_SUCCESS) {
                     85:           return 2;
                     86:         }
                     87: 
                     88:         return 0;
                     89:       }
                     90:     ], [
                     91:       have_clock_get_time=yes
                     92:       AC_MSG_RESULT([yes])
                     93:     ], [
                     94:       AC_MSG_RESULT([no])
                     95:     ])
                     96:   fi
                     97: 
                     98:   if test "$have_clock_get_time" = "yes"; then
                     99:     AC_DEFINE([HAVE_CLOCK_GET_TIME], 1, [do we have clock_get_time?])
                    100:   fi
                    101: ])
                    102: 
                    103: AC_DEFUN([AC_FPM_TRACE],
                    104: [
                    105:   have_ptrace=no
                    106:   have_broken_ptrace=no
                    107: 
                    108:   AC_MSG_CHECKING([for ptrace])
                    109: 
                    110:   AC_TRY_COMPILE([
                    111:     #include <sys/types.h>
                    112:     #include <sys/ptrace.h> ], [ptrace(0, 0, (void *) 0, 0);], [
                    113:     have_ptrace=yes
                    114:     AC_MSG_RESULT([yes])
                    115:   ], [
                    116:     AC_MSG_RESULT([no])
                    117:   ])
                    118: 
                    119:   if test "$have_ptrace" = "yes"; then
                    120:     AC_MSG_CHECKING([whether ptrace works])
                    121: 
                    122:     AC_TRY_RUN([
                    123:       #include <unistd.h>
                    124:       #include <signal.h>
                    125:       #include <sys/wait.h>
                    126:       #include <sys/types.h>
                    127:       #include <sys/ptrace.h>
                    128:       #include <errno.h>
                    129: 
                    130:       #if !defined(PTRACE_ATTACH) && defined(PT_ATTACH)
                    131:       #define PTRACE_ATTACH PT_ATTACH
                    132:       #endif
                    133: 
                    134:       #if !defined(PTRACE_DETACH) && defined(PT_DETACH)
                    135:       #define PTRACE_DETACH PT_DETACH
                    136:       #endif
                    137: 
                    138:       #if !defined(PTRACE_PEEKDATA) && defined(PT_READ_D)
                    139:       #define PTRACE_PEEKDATA PT_READ_D
                    140:       #endif
                    141: 
                    142:       int main()
                    143:       {
                    144:         long v1 = (unsigned int) -1; /* copy will fail if sizeof(long) == 8 and we've got "int ptrace()" */
                    145:         long v2;
                    146:         pid_t child;
                    147:         int status;
                    148: 
                    149:         if ( (child = fork()) ) { /* parent */
                    150:           int ret = 0;
                    151: 
                    152:           if (0 > ptrace(PTRACE_ATTACH, child, 0, 0)) {
                    153:             return 2;
                    154:           }
                    155: 
                    156:           waitpid(child, &status, 0);
                    157: 
                    158:       #ifdef PT_IO
                    159:           struct ptrace_io_desc ptio = {
                    160:             .piod_op = PIOD_READ_D,
                    161:             .piod_offs = &v1,
                    162:             .piod_addr = &v2,
                    163:             .piod_len = sizeof(v1)
                    164:           };
                    165: 
                    166:           if (0 > ptrace(PT_IO, child, (void *) &ptio, 0)) {
                    167:             ret = 3;
                    168:           }
                    169:       #else
                    170:           errno = 0;
                    171: 
                    172:           v2 = ptrace(PTRACE_PEEKDATA, child, (void *) &v1, 0);
                    173: 
                    174:           if (errno) {
                    175:             ret = 4;
                    176:           }
                    177:       #endif
                    178:           ptrace(PTRACE_DETACH, child, (void *) 1, 0);
                    179: 
                    180:           kill(child, SIGKILL);
                    181: 
                    182:           return ret ? ret : (v1 != v2);
                    183:         }
                    184:         else { /* child */
                    185:           sleep(10);
                    186:           return 0;
                    187:         }
                    188:       }
                    189:     ], [
                    190:       AC_MSG_RESULT([yes])
                    191:     ], [
                    192:       have_ptrace=no
                    193:       have_broken_ptrace=yes
                    194:       AC_MSG_RESULT([no])
                    195:     ])
                    196:   fi
                    197: 
                    198:   if test "$have_ptrace" = "yes"; then
                    199:     AC_DEFINE([HAVE_PTRACE], 1, [do we have ptrace?])
                    200:   fi
                    201: 
                    202:   have_mach_vm_read=no
                    203: 
                    204:   if test "$have_broken_ptrace" = "yes"; then
                    205:     AC_MSG_CHECKING([for mach_vm_read])
                    206: 
                    207:     AC_TRY_COMPILE([ #include <mach/mach.h>
                    208:       #include <mach/mach_vm.h>
                    209:     ], [
                    210:       mach_vm_read((vm_map_t)0, (mach_vm_address_t)0, (mach_vm_size_t)0, (vm_offset_t *)0, (mach_msg_type_number_t*)0);
                    211:     ], [
                    212:       have_mach_vm_read=yes
                    213:       AC_MSG_RESULT([yes])
                    214:     ], [
                    215:       AC_MSG_RESULT([no])
                    216:     ])
                    217:   fi
                    218: 
                    219:   if test "$have_mach_vm_read" = "yes"; then
                    220:     AC_DEFINE([HAVE_MACH_VM_READ], 1, [do we have mach_vm_read?])
                    221:   fi
                    222: 
                    223:   proc_mem_file=""
                    224: 
                    225:   if test -r /proc/$$/mem ; then
                    226:     proc_mem_file="mem"
                    227:   else
                    228:     if test -r /proc/$$/as ; then
                    229:       proc_mem_file="as"
                    230:     fi
                    231:   fi
                    232: 
                    233:   if test -n "$proc_mem_file" ; then
                    234:     AC_MSG_CHECKING([for proc mem file])
                    235:   
                    236:     AC_TRY_RUN([
                    237:       #define _GNU_SOURCE
                    238:       #define _FILE_OFFSET_BITS 64
                    239:       #include <stdint.h>
                    240:       #include <unistd.h>
                    241:       #include <sys/types.h>
                    242:       #include <sys/stat.h>
                    243:       #include <fcntl.h>
                    244:       #include <stdio.h>
                    245:       int main()
                    246:       {
                    247:         long v1 = (unsigned int) -1, v2 = 0;
                    248:         char buf[128];
                    249:         int fd;
                    250:         sprintf(buf, "/proc/%d/$proc_mem_file", getpid());
                    251:         fd = open(buf, O_RDONLY);
                    252:         if (0 > fd) {
                    253:           return 1;
                    254:         }
                    255:         if (sizeof(long) != pread(fd, &v2, sizeof(long), (uintptr_t) &v1)) {
                    256:           close(fd);
                    257:           return 1;
                    258:         }
                    259:         close(fd);
                    260:         return v1 != v2;
                    261:       }
                    262:     ], [
                    263:       AC_MSG_RESULT([$proc_mem_file])
                    264:     ], [
                    265:       proc_mem_file=""
                    266:       AC_MSG_RESULT([no])
                    267:     ])
                    268:   fi
                    269:   
                    270:   if test -n "$proc_mem_file"; then
                    271:     AC_DEFINE_UNQUOTED([PROC_MEM_FILE], "$proc_mem_file", [/proc/pid/mem interface])
                    272:   fi
                    273:   
                    274:   fpm_trace_type=""
                    275: 
                    276:   if test "$have_ptrace" = "yes"; then
                    277:     fpm_trace_type=ptrace
                    278:     
                    279:   elif test -n "$proc_mem_file"; then
                    280:     fpm_trace_type=pread
                    281:     
                    282:   elif test "$have_mach_vm_read" = "yes" ; then
                    283:     fpm_trace_type=mach
                    284:     
                    285:   else
                    286:     AC_MSG_WARN([FPM Trace - ptrace, pread, or mach: could not be found])    
                    287:   fi
                    288:   
                    289: ])
                    290: 
                    291: AC_DEFUN([AC_FPM_BUILTIN_ATOMIC],
                    292: [
                    293:   AC_MSG_CHECKING([if gcc supports __sync_bool_compare_and_swap])
                    294:   AC_TRY_LINK(,
                    295:   [
                    296:     int variable = 1;
                    297:     return (__sync_bool_compare_and_swap(&variable, 1, 2)
                    298:            && __sync_add_and_fetch(&variable, 1)) ? 1 : 0;
                    299:   ],
                    300:   [
                    301:     AC_MSG_RESULT([yes])
                    302:     AC_DEFINE(HAVE_BUILTIN_ATOMIC, 1, [Define to 1 if gcc supports __sync_bool_compare_and_swap() a.o.])
                    303:   ],
                    304:   [
                    305:     AC_MSG_RESULT([no])
                    306:   ])
                    307: ])
                    308: 
                    309: AC_DEFUN([AC_FPM_LQ],
                    310: [
                    311:   have_lq=no
                    312: 
                    313:   AC_MSG_CHECKING([for TCP_INFO])
                    314: 
                    315:   AC_TRY_COMPILE([ #include <netinet/tcp.h> ], [struct tcp_info ti; ti.tcpi_sacked = 0; int x = TCP_INFO;], [
                    316:     have_lq=tcp_info
                    317:     AC_MSG_RESULT([yes])
                    318:   ], [
                    319:     AC_MSG_RESULT([no])
                    320:   ])
                    321: 
                    322:   if test "$have_lq" = "tcp_info"; then
                    323:     AC_DEFINE([HAVE_LQ_TCP_INFO], 1, [do we have TCP_INFO?])
                    324:   fi
                    325: 
                    326:   if test "$have_lq" = "no" ; then
                    327:     AC_MSG_CHECKING([for SO_LISTENQLEN])
                    328: 
                    329:     AC_TRY_COMPILE([ #include <sys/socket.h> ], [int x = SO_LISTENQLIMIT; int y = SO_LISTENQLEN;], [
                    330:       have_lq=so_listenq
                    331:       AC_MSG_RESULT([yes])
                    332:     ], [
                    333:       AC_MSG_RESULT([no])
                    334:     ])
                    335: 
                    336:     if test "$have_lq" = "so_listenq"; then
                    337:       AC_DEFINE([HAVE_LQ_SO_LISTENQ], 1, [do we have SO_LISTENQxxx?])
                    338:     fi
                    339:   fi
                    340: ])
                    341: dnl }}}
                    342: 
                    343: AC_DEFUN([AC_FPM_SYSCONF],
                    344: [
                    345:        AC_MSG_CHECKING([for sysconf])
                    346: 
                    347:        AC_TRY_COMPILE([ #include <unistd.h> ], [sysconf(_SC_CLK_TCK);], [
                    348:                AC_DEFINE([HAVE_SYSCONF], 1, [do we have sysconf?])
                    349:                AC_MSG_RESULT([yes])
                    350:        ], [
                    351:                AC_MSG_RESULT([no])
                    352:        ])
                    353: ])
                    354: dnl }}}
                    355: 
                    356: AC_DEFUN([AC_FPM_TIMES],
                    357: [
                    358:        AC_MSG_CHECKING([for times])
                    359: 
                    360:        AC_TRY_COMPILE([ #include <sys/times.h> ], [struct tms t; times(&t);], [
                    361:                AC_DEFINE([HAVE_TIMES], 1, [do we have times?])
                    362:                AC_MSG_RESULT([yes])
                    363:        ], [
                    364:                AC_MSG_RESULT([no])
                    365:        ])
                    366: ])
                    367: dnl }}}
                    368: 
                    369: AC_DEFUN([AC_FPM_KQUEUE],
                    370: [
                    371:        AC_MSG_CHECKING([for kqueue])
                    372: 
                    373:        AC_TRY_COMPILE(
                    374:        [ 
                    375:                #include <sys/types.h>
                    376:                #include <sys/event.h>
                    377:                #include <sys/time.h>
                    378:        ], [
                    379:                int kfd;
                    380:                struct kevent k;
                    381:                kfd = kqueue();
                    382:                /* 0 -> STDIN_FILENO */
                    383:                EV_SET(&k, 0, EVFILT_READ , EV_ADD | EV_CLEAR, 0, 0, NULL);
                    384:        ], [
                    385:                AC_DEFINE([HAVE_KQUEUE], 1, [do we have kqueue?])
                    386:                AC_MSG_RESULT([yes])
                    387:        ], [
                    388:                AC_MSG_RESULT([no])
                    389:        ])
                    390: ])
                    391: dnl }}}
                    392: 
                    393: AC_DEFUN([AC_FPM_PORT],
                    394: [
                    395:        AC_MSG_CHECKING([for port framework])
                    396: 
                    397:        AC_TRY_COMPILE(
                    398:        [ 
                    399:                #include <port.h>
                    400:        ], [
                    401:                int port;
                    402: 
                    403:                port = port_create();
                    404:                if (port < 0) {
                    405:                        return 1;
                    406:                }
                    407:        ], [
                    408:                AC_DEFINE([HAVE_PORT], 1, [do we have port framework?])
                    409:                AC_MSG_RESULT([yes])
                    410:        ], [
                    411:                AC_MSG_RESULT([no])
                    412:        ])
                    413: ])
                    414: dnl }}}
                    415: 
                    416: AC_DEFUN([AC_FPM_DEVPOLL],
                    417: [
                    418:        AC_MSG_CHECKING([for /dev/poll])
                    419: 
                    420:        AC_TRY_COMPILE(
                    421:        [ 
                    422:                #include <stdio.h>
                    423:                #include <sys/devpoll.h>
                    424:        ], [
                    425:                int n, dp;
                    426:                struct dvpoll dvp;
                    427:                dp = 0;
                    428:                dvp.dp_fds = NULL;
                    429:                dvp.dp_nfds = 0;
                    430:                dvp.dp_timeout = 0;
                    431:                n = ioctl(dp, DP_POLL, &dvp)
                    432:        ], [
                    433:                AC_DEFINE([HAVE_DEVPOLL], 1, [do we have /dev/poll?])
                    434:                AC_MSG_RESULT([yes])
                    435:        ], [
                    436:                AC_MSG_RESULT([no])
                    437:        ])
                    438: ])
                    439: dnl }}}
                    440: 
                    441: AC_DEFUN([AC_FPM_EPOLL],
                    442: [
                    443:        AC_MSG_CHECKING([for epoll])
                    444: 
                    445:        AC_TRY_COMPILE(
                    446:        [ 
                    447:                #include <sys/epoll.h>
                    448:        ], [
                    449:                int epollfd;
                    450:                struct epoll_event e;
                    451: 
                    452:                epollfd = epoll_create(1);
                    453:                if (epollfd < 0) {
                    454:                        return 1;
                    455:                }
                    456: 
                    457:                e.events = EPOLLIN | EPOLLET;
                    458:                e.data.fd = 0;
                    459: 
                    460:                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, 0, &e) == -1) {
                    461:                        return 1;
                    462:                }
                    463: 
                    464:                e.events = 0;
                    465:                if (epoll_wait(epollfd, &e, 1, 1) < 0) {
                    466:                        return 1;
                    467:                }
                    468:        ], [
                    469:                AC_DEFINE([HAVE_EPOLL], 1, [do we have epoll?])
                    470:                AC_MSG_RESULT([yes])
                    471:        ], [
                    472:                AC_MSG_RESULT([no])
                    473:        ])
                    474: ])
                    475: dnl }}}
                    476: 
                    477: AC_DEFUN([AC_FPM_POLL],
                    478: [
                    479:        AC_MSG_CHECKING([for poll])
                    480: 
                    481:        AC_TRY_COMPILE(
                    482:        [ 
                    483:                #include <poll.h>
                    484:        ], [
                    485:                struct pollfd fds[2];
                    486: 
                    487:                fds[0].fd = 0;
                    488:                fds[0].events = POLLIN;
                    489: 
                    490:                fds[1].fd = 0;
                    491:                fds[1].events = POLLIN;
                    492: 
                    493:                 poll(fds, 2, 1);
                    494:        ], [
                    495:                AC_DEFINE([HAVE_POLL], 1, [do we have poll?])
                    496:                AC_MSG_RESULT([yes])
                    497:        ], [
                    498:                AC_MSG_RESULT([no])
                    499:        ])
                    500: ])
                    501: dnl }}}
                    502: 
                    503: AC_DEFUN([AC_FPM_SELECT],
                    504: [
                    505:        AC_MSG_CHECKING([for select])
                    506: 
                    507:        AC_TRY_COMPILE(
                    508:        [ 
                    509:                /* According to POSIX.1-2001 */
                    510:                #include <sys/select.h>
                    511: 
                    512:                /* According to earlier standards */
                    513:                #include <sys/time.h>
                    514:                #include <sys/types.h>
                    515:                #include <unistd.h>
                    516:        ], [
                    517:                fd_set fds;
                    518:                struct timeval t;
                    519:                t.tv_sec = 0;
                    520:                t.tv_usec = 42;
                    521:                FD_ZERO(&fds);
                    522:                /* 0 -> STDIN_FILENO */
                    523:                FD_SET(0, &fds);
                    524:                select(FD_SETSIZE, &fds, NULL, NULL, &t);
                    525:        ], [
                    526:                AC_DEFINE([HAVE_SELECT], 1, [do we have select?])
                    527:                AC_MSG_RESULT([yes])
                    528:        ], [
                    529:                AC_MSG_RESULT([no])
                    530:        ])
                    531: ])
                    532: dnl }}}
                    533: 
                    534: 
                    535: AC_MSG_CHECKING(for FPM build)
                    536: if test "$PHP_FPM" != "no"; then
                    537:   AC_MSG_RESULT($PHP_FPM)
                    538: 
                    539:   AC_FPM_STDLIBS
                    540:   AC_FPM_PRCTL
                    541:   AC_FPM_CLOCK
                    542:   AC_FPM_TRACE
                    543:   AC_FPM_BUILTIN_ATOMIC
                    544:   AC_FPM_LQ
                    545:        AC_FPM_SYSCONF
                    546:        AC_FPM_TIMES
                    547:        AC_FPM_KQUEUE
                    548:        AC_FPM_PORT
                    549:        AC_FPM_DEVPOLL
                    550:        AC_FPM_EPOLL
                    551:        AC_FPM_POLL
                    552:        AC_FPM_SELECT
                    553: 
                    554:   PHP_ARG_WITH(fpm-user,,
                    555:   [  --with-fpm-user[=USER]  Set the user for php-fpm to run as. (default: nobody)], nobody, no)
                    556: 
                    557:   PHP_ARG_WITH(fpm-group,,
                    558:   [  --with-fpm-group[=GRP]  Set the group for php-fpm to run as. For a system user, this 
                    559:                   should usually be set to match the fpm username (default: nobody)], nobody, no)
                    560: 
                    561:   if test -z "$PHP_FPM_USER" -o "$PHP_FPM_USER" = "yes" -o "$PHP_FPM_USER" = "no"; then
                    562:     php_fpm_user="nobody"
                    563:   else
                    564:     php_fpm_user="$PHP_FPM_USER"
                    565:   fi
                    566: 
                    567:   if test -z "$PHP_FPM_GROUP" -o "$PHP_FPM_GROUP" = "yes" -o "$PHP_FPM_GROUP" = "no"; then
                    568:     php_fpm_group="nobody"
                    569:   else
                    570:     php_fpm_group="$PHP_FPM_GROUP"
                    571:   fi
                    572: 
                    573:   PHP_SUBST_OLD(php_fpm_user)
                    574:   PHP_SUBST_OLD(php_fpm_group)
                    575:   php_fpm_sysconfdir=`eval echo $sysconfdir`
                    576:   PHP_SUBST_OLD(php_fpm_sysconfdir)
                    577:   php_fpm_localstatedir=`eval echo $localstatedir`
                    578:   PHP_SUBST_OLD(php_fpm_localstatedir)
                    579:   php_fpm_prefix=`eval echo $prefix`
                    580:   PHP_SUBST_OLD(php_fpm_prefix)
                    581: 
                    582:   AC_DEFINE_UNQUOTED(PHP_FPM_USER, "$php_fpm_user", [fpm user name])
                    583:   AC_DEFINE_UNQUOTED(PHP_FPM_GROUP, "$php_fpm_group", [fpm group name])
                    584: 
1.1.1.2 ! misho     585:   PHP_ADD_BUILD_DIR(sapi/fpm/fpm)
        !           586:   PHP_ADD_BUILD_DIR(sapi/fpm/fpm/events)
1.1       misho     587:   PHP_OUTPUT(sapi/fpm/php-fpm.conf sapi/fpm/init.d.php-fpm sapi/fpm/php-fpm.8 sapi/fpm/status.html)
1.1.1.2 ! misho     588:   PHP_ADD_MAKEFILE_FRAGMENT([$abs_srcdir/sapi/fpm/Makefile.frag])
1.1       misho     589: 
                    590:   SAPI_FPM_PATH=sapi/fpm/php-fpm
                    591:   
                    592:   if test "$fpm_trace_type" && test -f "$abs_srcdir/sapi/fpm/fpm/fpm_trace_$fpm_trace_type.c"; then
                    593:     PHP_FPM_TRACE_FILES="fpm/fpm_trace.c fpm/fpm_trace_$fpm_trace_type.c"
                    594:   fi
                    595:   
                    596:   PHP_FPM_CFLAGS="-I$abs_srcdir/sapi/fpm"
                    597:  
                    598:   PHP_FPM_FILES="fpm/fastcgi.c \
                    599:     fpm/fpm.c \
                    600:     fpm/fpm_children.c \
                    601:     fpm/fpm_cleanup.c \
                    602:     fpm/fpm_clock.c \
                    603:     fpm/fpm_conf.c \
                    604:     fpm/fpm_env.c \
                    605:     fpm/fpm_events.c \
                    606:                fpm/fpm_log.c \
                    607:     fpm/fpm_main.c \
                    608:     fpm/fpm_php.c \
                    609:     fpm/fpm_php_trace.c \
                    610:     fpm/fpm_process_ctl.c \
                    611:     fpm/fpm_request.c \
                    612:     fpm/fpm_shm.c \
                    613:     fpm/fpm_scoreboard.c \
                    614:     fpm/fpm_signals.c \
                    615:     fpm/fpm_sockets.c \
                    616:     fpm/fpm_status.c \
                    617:     fpm/fpm_stdio.c \
                    618:     fpm/fpm_unix.c \
                    619:     fpm/fpm_worker_pool.c \
                    620:     fpm/zlog.c \
                    621:                fpm/events/select.c \
                    622:                fpm/events/poll.c \
                    623:                fpm/events/epoll.c \
                    624:                fpm/events/kqueue.c \
                    625:                fpm/events/devpoll.c \
                    626:                fpm/events/port.c \
                    627:   "
                    628: 
1.1.1.2 ! misho     629:   PHP_SELECT_SAPI(fpm, program, $PHP_FPM_FILES $PHP_FPM_TRACE_FILES, $PHP_FPM_CFLAGS, '$(SAPI_FPM_PATH)')
1.1       misho     630: 
                    631:   case $host_alias in
                    632:       *aix*)
1.1.1.2 ! misho     633:         BUILD_FPM="echo '\#! .' > php.sym && echo >>php.sym && nm -BCpg \`echo \$(PHP_GLOBAL_OBJS) \$(PHP_BINARY_OBJS) \$(PHP_FPM_OBJS) | sed 's/\([A-Za-z0-9_]*\)\.lo/\1.o/g'\` | \$(AWK) '{ if (((\$\$2 == \"T\") || (\$\$2 == \"D\") || (\$\$2 == \"B\")) && (substr(\$\$3,1,1) != \".\")) { print \$\$3 } }' | sort -u >> php.sym && \$(LIBTOOL) --mode=link \$(CC) -export-dynamic \$(CFLAGS_CLEAN) \$(EXTRA_CFLAGS) \$(EXTRA_LDFLAGS_PROGRAM) \$(LDFLAGS) -Wl,-brtl -Wl,-bE:php.sym \$(PHP_RPATHS) \$(PHP_GLOBAL_OBJS) \$(PHP_FPM_OBJS) \$(EXTRA_LIBS) \$(FPM_EXTRA_LIBS) \$(ZEND_EXTRA_LIBS) -o \$(SAPI_FPM_PATH)"
1.1       misho     634:         ;;
                    635:       *darwin*)
1.1.1.2 ! misho     636:         BUILD_FPM="\$(CC) \$(CFLAGS_CLEAN) \$(EXTRA_CFLAGS) \$(EXTRA_LDFLAGS_PROGRAM) \$(LDFLAGS) \$(NATIVE_RPATHS) \$(PHP_GLOBAL_OBJS:.lo=.o) \$(PHP_BINARY_OBJS:.lo=.o) \$(PHP_FPM_OBJS:.lo=.o) \$(PHP_FRAMEWORKS) \$(EXTRA_LIBS) \$(FPM_EXTRA_LIBS) \$(ZEND_EXTRA_LIBS) -o \$(SAPI_FPM_PATH)"
1.1       misho     637:       ;;
                    638:       *)
1.1.1.2 ! misho     639:         BUILD_FPM="\$(LIBTOOL) --mode=link \$(CC) -export-dynamic \$(CFLAGS_CLEAN) \$(EXTRA_CFLAGS) \$(EXTRA_LDFLAGS_PROGRAM) \$(LDFLAGS) \$(PHP_RPATHS) \$(PHP_GLOBAL_OBJS) \$(PHP_BINARY_OBJS) \$(PHP_FPM_OBJS) \$(EXTRA_LIBS) \$(FPM_EXTRA_LIBS) \$(ZEND_EXTRA_LIBS) -o \$(SAPI_FPM_PATH)"
1.1       misho     640:       ;;
                    641:   esac
                    642: 
1.1.1.2 ! misho     643:   PHP_SUBST(SAPI_FPM_PATH)
1.1       misho     644:   PHP_SUBST(BUILD_FPM)
1.1.1.2 ! misho     645: 
1.1       misho     646: else
                    647:   AC_MSG_RESULT(no)
                    648: fi

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>