├── CREDITS ├── tests ├── config.php-dist ├── 002_ipv4.phpt ├── 002_ipv6.phpt ├── 003_ipv4.phpt ├── 003_ipv6.phpt ├── 002_shm.phpt ├── 011_ipv4.phpt ├── 011_ipv6.phpt ├── 002_secret.phpt ├── 003_shm.phpt ├── 003_secret.phpt ├── 001.phpt ├── 005_ipv4.phpt ├── 005_ipv6.phpt ├── 011_shm.phpt ├── 010_ipv4.phpt ├── 010_ipv6.phpt ├── 011_secret.phpt ├── 007_shm.phpt ├── 006_ipv4.phpt ├── 006_ipv6.phpt ├── 005_secret.phpt ├── 010_shm.phpt ├── 005_shm.phpt ├── 007_secret.phpt ├── 010_secret.phpt ├── 008_shm.phpt ├── 006_secret.phpt ├── 006_shm.phpt ├── 008_secret.phpt ├── 004_ipv4.phpt ├── 004_ipv6.phpt ├── 009_ipv4.phpt ├── 009_ipv6.phpt ├── README ├── 004_secret.phpt ├── 004_shm.phpt ├── 009_shm.phpt └── 009_secret.phpt ├── config.w32 ├── LICENSE ├── varnish.stub.php ├── exception.h ├── exception.c ├── varnish_arginfo.h ├── config.m4 ├── php_varnish.h ├── stat.c ├── log.c ├── varnish_lib.h ├── varnish.c ├── package.xml ├── adm.c └── varnish_lib.c /CREDITS: -------------------------------------------------------------------------------- 1 | varnish -------------------------------------------------------------------------------- /tests/config.php-dist: -------------------------------------------------------------------------------- 1 | "/var/lib/varnish/silent", 5 | "timeout" => 1000, 6 | ); 7 | 8 | $args_ipv4 = array( 9 | "host" => "127.0.0.1", 10 | "port" => 6082, 11 | "secret" => "3cc62b09-5c5b-4322-9660-25817d148612", 12 | "timeout" => 1000, 13 | ); 14 | 15 | $args_ipv6 = array( 16 | "host" => "::1", 17 | "port" => 6082, 18 | "secret" => "3cc62b09-5c5b-4322-9660-25817d148612", 19 | "timeout" => 1000, 20 | ); 21 | 22 | -------------------------------------------------------------------------------- /tests/002_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect()); 15 | echo "\n"; 16 | 17 | ?> 18 | --EXPECT-- 19 | true 20 | -------------------------------------------------------------------------------- /tests/002_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect()); 15 | echo "\n"; 16 | 17 | ?> 18 | --EXPECT-- 19 | true 20 | -------------------------------------------------------------------------------- /tests/003_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish authentication 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | var_export($va->auth()); 16 | echo "\n"; 17 | 18 | ?> 19 | --EXPECT-- 20 | true 21 | -------------------------------------------------------------------------------- /tests/003_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish authentication 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | var_export($va->auth()); 16 | echo "\n"; 17 | 18 | ?> 19 | --EXPECT-- 20 | true 21 | -------------------------------------------------------------------------------- /tests/002_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect()); 16 | echo "\n"; 17 | 18 | ?> 19 | --EXPECT-- 20 | true 21 | -------------------------------------------------------------------------------- /tests/011_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection close 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | disconnect()); 15 | echo "\n"; 16 | $va->connect(); 17 | var_export($va->disconnect()); 18 | echo "\n"; 19 | 20 | ?> 21 | --EXPECT-- 22 | false 23 | true 24 | -------------------------------------------------------------------------------- /tests/011_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection close 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | disconnect()); 15 | echo "\n"; 16 | $va->connect(); 17 | var_export($va->disconnect()); 18 | echo "\n"; 19 | 20 | ?> 21 | --EXPECT-- 22 | false 23 | true 24 | -------------------------------------------------------------------------------- /tests/002_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect()); 16 | echo "\n"; 17 | 18 | ?> 19 | --EXPECT-- 20 | true 21 | -------------------------------------------------------------------------------- /tests/003_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish authentication 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | var_export($va->auth()); 17 | echo "\n"; 18 | 19 | ?> 20 | --EXPECT-- 21 | true 22 | -------------------------------------------------------------------------------- /tests/003_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish authentication 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | var_export($va->auth()); 17 | echo "\n"; 18 | 19 | ?> 20 | --EXPECT-- 21 | true 22 | -------------------------------------------------------------------------------- /tests/001.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish presence 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | 20 | --EXPECT-- 21 | varnish extension is available 22 | -------------------------------------------------------------------------------- /tests/005_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish stop/start 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 16 | $va->auth(); 17 | 18 | echo $va->stop() . "\n"; 19 | sleep(2); 20 | echo $va->start() . "\n"; 21 | sleep(2); 22 | 23 | ?> 24 | --EXPECT-- 25 | 200 26 | 200 27 | -------------------------------------------------------------------------------- /tests/005_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish stop/start 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 16 | $va->auth(); 17 | 18 | echo $va->stop() . "\n"; 19 | sleep(2); 20 | echo $va->start() . "\n"; 21 | sleep(2); 22 | 23 | ?> 24 | --EXPECT-- 25 | 200 26 | 200 27 | -------------------------------------------------------------------------------- /tests/011_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection close 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | disconnect()); 16 | echo "\n"; 17 | $va->connect(); 18 | var_export($va->disconnect()); 19 | echo "\n"; 20 | 21 | ?> 22 | --EXPECT-- 23 | false 24 | true 25 | -------------------------------------------------------------------------------- /tests/010_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.use 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | $va->auth(); 16 | 17 | $list = $va->getVclList(); 18 | $name = $list[0]['name']; // thats enough to get the first best name 19 | 20 | $r = $va->vclUse($name); 21 | var_export($r); 22 | echo "\n"; 23 | 24 | ?> 25 | --EXPECT-- 26 | true 27 | -------------------------------------------------------------------------------- /tests/010_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.use 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | $va->auth(); 16 | 17 | $list = $va->getVclList(); 18 | $name = $list[0]['name']; // thats enough to get the first best name 19 | 20 | $r = $va->vclUse($name); 21 | var_export($r); 22 | echo "\n"; 23 | 24 | ?> 25 | --EXPECT-- 26 | true 27 | -------------------------------------------------------------------------------- /tests/011_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish connection close 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | disconnect()); 16 | echo "\n"; 17 | $va->connect(); 18 | var_export($va->disconnect()); 19 | echo "\n"; 20 | 21 | ?> 22 | --EXPECT-- 23 | false 24 | true 25 | -------------------------------------------------------------------------------- /tests/007_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for VarnishStat::getSnapshot functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | 8 | --FILE-- 9 | getSnapshot(); 16 | 17 | echo (int)is_array($stat), "\n"; 18 | echo (int)!empty($stat), "\n"; 19 | 20 | ?> 21 | --EXPECT-- 22 | 1 23 | 1 24 | -------------------------------------------------------------------------------- /tests/006_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish status functionality 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 17 | $va->auth(); 18 | 19 | $va->stop(); 20 | echo (int)$va->isRunning(), "\n"; 21 | sleep(2); 22 | 23 | $va->start(); 24 | echo (int)$va->isRunning(), "\n"; 25 | sleep(2); 26 | 27 | ?> 28 | --EXPECT-- 29 | 0 30 | 1 31 | -------------------------------------------------------------------------------- /tests/006_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish status functionality 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 17 | $va->auth(); 18 | 19 | $va->stop(); 20 | echo (int)$va->isRunning(), "\n"; 21 | sleep(2); 22 | 23 | $va->start(); 24 | echo (int)$va->isRunning(), "\n"; 25 | sleep(2); 26 | 27 | ?> 28 | --EXPECT-- 29 | 0 30 | 1 31 | -------------------------------------------------------------------------------- /tests/005_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish stop/start 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 17 | $va->auth(); 18 | 19 | echo $va->stop() . "\n"; 20 | sleep(2); 21 | echo $va->start() . "\n"; 22 | sleep(2); 23 | 24 | ?> 25 | --EXPECT-- 26 | 200 27 | 200 28 | -------------------------------------------------------------------------------- /tests/010_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.use 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | $va->auth(); 17 | 18 | $list = $va->getVclList(); 19 | $name = $list[0]['name']; // thats enough to get the first best name 20 | 21 | $r = $va->vclUse($name); 22 | var_export($r); 23 | echo "\n"; 24 | 25 | ?> 26 | --EXPECT-- 27 | true 28 | -------------------------------------------------------------------------------- /tests/005_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish stop/start 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 18 | $va->auth(); 19 | 20 | echo $va->stop() . "\n"; 21 | sleep(2); 22 | echo $va->start() . "\n"; 23 | sleep(2); 24 | 25 | ?> 26 | --EXPECT-- 27 | 200 28 | 200 29 | -------------------------------------------------------------------------------- /tests/007_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for VarnishStat::getSnapshot functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | 8 | --FILE-- 9 | getSnapshot(); 16 | 17 | echo (int)is_array($stat), "\n"; 18 | echo (int)!empty($stat), "\n"; 19 | 20 | ?> 21 | --EXPECT-- 22 | 1 23 | 1 24 | -------------------------------------------------------------------------------- /tests/010_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.use 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | $va->auth(); 17 | 18 | $list = $va->getVclList(); 19 | $name = $list[0]['name']; // thats enough to get the first best name 20 | 21 | $r = $va->vclUse($name); 22 | var_export($r); 23 | echo "\n"; 24 | 25 | ?> 26 | --EXPECT-- 27 | true 28 | -------------------------------------------------------------------------------- /tests/008_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for the basic VarnishLog::getLine() functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | 8 | --FILE-- 9 | 0) { 16 | $line = $vs->getLine(); 17 | echo (int)is_array($line), "\n"; 18 | echo (int)!empty($line), "\n"; 19 | } 20 | 21 | ?> 22 | --EXPECT-- 23 | 1 24 | 1 25 | 1 26 | 1 27 | 1 28 | 1 29 | -------------------------------------------------------------------------------- /tests/006_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish status functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 18 | $va->auth(); 19 | 20 | $va->stop(); 21 | echo (int)$va->isRunning(), "\n"; 22 | sleep(2); 23 | 24 | $va->start(); 25 | echo (int)$va->isRunning(), "\n"; 26 | sleep(2); 27 | 28 | ?> 29 | --EXPECT-- 30 | 0 31 | 1 32 | -------------------------------------------------------------------------------- /tests/006_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish status functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 19 | $va->auth(); 20 | 21 | $va->stop(); 22 | echo (int)$va->isRunning(), "\n"; 23 | sleep(2); 24 | 25 | $va->start(); 26 | echo (int)$va->isRunning(), "\n"; 27 | sleep(2); 28 | 29 | ?> 30 | --EXPECT-- 31 | 0 32 | 1 33 | -------------------------------------------------------------------------------- /tests/008_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for the basic VarnishLog::getLine() functionality 3 | --SKIPIF-- 4 | 5 | 6 | 7 | 8 | --FILE-- 9 | 0) { 16 | $line = $vs->getLine(); 17 | echo (int)is_array($line), "\n"; 18 | echo (int)!empty($line), "\n"; 19 | } 20 | 21 | ?> 22 | --EXPECT-- 23 | 1 24 | 1 25 | 1 26 | 1 27 | 1 28 | 1 29 | -------------------------------------------------------------------------------- /config.w32: -------------------------------------------------------------------------------- 1 | // $Id$ 2 | // vim:ft=javascript 3 | 4 | ARG_ENABLE("varnish", "enable varnish support", "no"); 5 | 6 | if (PHP_VARNISH != "no") { 7 | if (CHECK_HEADER_ADD_INCLUDE('Ws2tcpip.h', 'CFLAGS_VARNISH') && 8 | CHECK_HEADER_ADD_INCLUDE("php_varnish.h", "CFLAGS_VARNISH", PHP_VARNISH + ";" + configure_module_dirname) && 9 | CHECK_HEADER_ADD_INCLUDE("exception.h", "CFLAGS_VARNISH", PHP_VARNISH + ";" + configure_module_dirname) && 10 | CHECK_HEADER_ADD_INCLUDE("varnish_lib.h", "CFLAGS_VARNISH", PHP_VARNISH + ";" + configure_module_dirname) && 11 | CHECK_LIB('Ws2_32.lib', 'varnish')) { 12 | 13 | ADD_EXTENSION_DEP("varnish", "hash", false); 14 | 15 | EXTENSION("varnish", "varnish.c varnish_lib.c adm.c exception.c log.c stat.c"); 16 | 17 | AC_DEFINE('HAVE_VARNISH', 1, 'Have varnish library'); 18 | } else { 19 | WARNING('varnish not enabled, headers missing'); 20 | } 21 | } 22 | 23 | -------------------------------------------------------------------------------- /tests/004_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish set/get params 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 17 | $va->auth(); 18 | 19 | $va->setParam("thread_pools", 20); 20 | $vparams = $va->getParams(); 21 | echo (int)$vparams['thread_pools'] . "\n"; 22 | 23 | $va->setParam("thread_pools", 30); 24 | $vparams = $va->getParams(); 25 | echo (int)$vparams['thread_pools'] . "\n"; 26 | 27 | $va->setParam("thread_pools", 40); 28 | $vparams = $va->getParams(); 29 | echo (int)$vparams['thread_pools'] . "\n"; 30 | 31 | ?> 32 | --EXPECT-- 33 | 20 34 | 30 35 | 40 36 | -------------------------------------------------------------------------------- /tests/004_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish set/get params 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 17 | $va->auth(); 18 | 19 | $va->setParam("thread_pools", 20); 20 | $vparams = $va->getParams(); 21 | echo (int)$vparams['thread_pools'] . "\n"; 22 | 23 | $va->setParam("thread_pools", 30); 24 | $vparams = $va->getParams(); 25 | echo (int)$vparams['thread_pools'] . "\n"; 26 | 27 | $va->setParam("thread_pools", 40); 28 | $vparams = $va->getParams(); 29 | echo (int)$vparams['thread_pools'] . "\n"; 30 | 31 | ?> 32 | --EXPECT-- 33 | 20 34 | 30 35 | 40 36 | -------------------------------------------------------------------------------- /tests/009_ipv4.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.list 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | $va->auth(); 16 | 17 | $list = $va->getVclList(); 18 | $r = $r && (count($list) > 0); 19 | $one_active = false; 20 | while ($r && (list(, $data) = each($list)) !== false) { 21 | $r = $r && (3 == count($data)); 22 | 23 | $r = $r && isset($data['status']); 24 | $r = $r && isset($data['locks']); 25 | $r = $r && isset($data['name']); 26 | 27 | if ('active' == $data['status']) { 28 | $one_active = true; 29 | } 30 | } 31 | 32 | $r = $r && $one_active; 33 | 34 | var_export($r); 35 | echo "\n"; 36 | 37 | ?> 38 | --EXPECT-- 39 | true 40 | -------------------------------------------------------------------------------- /tests/009_ipv6.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.list 3 | --SKIPIF-- 4 | 5 | 6 | --FILE-- 7 | connect(); 15 | $va->auth(); 16 | 17 | $list = $va->getVclList(); 18 | $r = $r && (count($list) > 0); 19 | $one_active = false; 20 | while ($r && (list(, $data) = each($list)) !== false) { 21 | $r = $r && (3 == count($data)); 22 | 23 | $r = $r && isset($data['status']); 24 | $r = $r && isset($data['locks']); 25 | $r = $r && isset($data['name']); 26 | 27 | if ('active' == $data['status']) { 28 | $one_active = true; 29 | } 30 | } 31 | 32 | $r = $r && $one_active; 33 | 34 | var_export($r); 35 | echo "\n"; 36 | 37 | ?> 38 | --EXPECT-- 39 | true 40 | -------------------------------------------------------------------------------- /tests/README: -------------------------------------------------------------------------------- 1 | Quick HOWTO run test from an unprivileged account under Linux 2 | 3 | Generate a configuration file 4 | 5 | $ sed -e 's:/var/lib/varnish/silent:/tmp/vtest:' \ 6 | tests/config.php-dist | tee tests/config.php 7 | 8 | Retrieve secret from configuration file 9 | 10 | $ sed -n '/secret/{s/.* "//;s/".*$//;p}' \ 11 | tests/config.php | tail -n 1 | tee /tmp/secret 12 | 13 | Run a varnish server under current account 14 | 15 | $ /usr/sbin/varnishd \ 16 | -b 127.0.0.1:80 \ 17 | -P /tmp/varnish.pid \ 18 | -S /tmp/secret \ 19 | -s file,/tmp,1G \ 20 | -n /tmp/vtest \ 21 | -a :6081 \ 22 | -T :6082 23 | 24 | Select the test types you want to run 25 | 26 | $ export VARNISH_TEST_IPV4=1 27 | $ export VARNISH_TEST_IPV6=1 28 | $ export VARNISH_TEST_SECRET=1 29 | $ export VARNISH_TEST_SHM=0 30 | $ export NO_INTERACTION=1 31 | 32 | Run the test suite 33 | 34 | $ make test 35 | 36 | Stop the server 37 | 38 | $ kill $(cat /tmp/varnish.pid) 39 | 40 | -------------------------------------------------------------------------------- /tests/004_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish set/get params 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 18 | $va->auth(); 19 | 20 | $va->setParam("thread_pools", 20); 21 | $vparams = $va->getParams(); 22 | echo (int)$vparams['thread_pools'] . "\n"; 23 | 24 | $va->setParam("thread_pools", 30); 25 | $vparams = $va->getParams(); 26 | echo (int)$vparams['thread_pools'] . "\n"; 27 | 28 | $va->setParam("thread_pools", 40); 29 | $vparams = $va->getParams(); 30 | echo (int)$vparams['thread_pools'] . "\n"; 31 | 32 | ?> 33 | --EXPECT-- 34 | 20 35 | 30 36 | 40 37 | -------------------------------------------------------------------------------- /tests/004_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for varnish set/get params 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 19 | $va->auth(); 20 | 21 | $va->setParam("thread_pools", 20); 22 | $vparams = $va->getParams(); 23 | echo (int)$vparams['thread_pools'] . "\n"; 24 | 25 | $va->setParam("thread_pools", 30); 26 | $vparams = $va->getParams(); 27 | echo (int)$vparams['thread_pools'] . "\n"; 28 | 29 | $va->setParam("thread_pools", 40); 30 | $vparams = $va->getParams(); 31 | echo (int)$vparams['thread_pools'] . "\n"; 32 | 33 | ?> 34 | --EXPECT-- 35 | 20 36 | 30 37 | 40 38 | -------------------------------------------------------------------------------- /tests/009_shm.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.list 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | $va->auth(); 17 | 18 | $list = $va->getVclList(); 19 | $r = $r && (count($list) > 0); 20 | $one_active = false; 21 | while ($r && (list(, $data) = each($list)) !== false) { 22 | $r = $r && (3 == count($data)); 23 | 24 | $r = $r && isset($data['status']); 25 | $r = $r && isset($data['locks']); 26 | $r = $r && isset($data['name']); 27 | 28 | if ('active' == $data['status']) { 29 | $one_active = true; 30 | } 31 | } 32 | 33 | $r = $r && $one_active; 34 | 35 | var_export($r); 36 | echo "\n"; 37 | 38 | ?> 39 | --EXPECT-- 40 | true 41 | -------------------------------------------------------------------------------- /tests/009_secret.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for vcl.list 3 | --SKIPIF-- 4 | 5 | 6 | 7 | --FILE-- 8 | connect(); 16 | $va->auth(); 17 | 18 | $list = $va->getVclList(); 19 | $r = $r && (count($list) > 0); 20 | $one_active = false; 21 | while ($r && (list(, $data) = each($list)) !== false) { 22 | $r = $r && (3 == count($data)); 23 | 24 | $r = $r && isset($data['status']); 25 | $r = $r && isset($data['locks']); 26 | $r = $r && isset($data['name']); 27 | 28 | if ('active' == $data['status']) { 29 | $one_active = true; 30 | } 31 | } 32 | 33 | $r = $r && $one_active; 34 | 35 | var_export($r); 36 | echo "\n"; 37 | 38 | ?> 39 | --EXPECT-- 40 | true 41 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011-2014 Anatol Belski 2 | All rights reserved. 3 | 4 | Author: Anatol Belski 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions 8 | are met: 9 | 1. Redistributions of source code must retain the above copyright 10 | notice, this list of conditions and the following disclaimer. 11 | 2. Redistributions in binary form must reproduce the above copyright 12 | notice, this list of conditions and the following disclaimer in the 13 | documentation and/or other materials provided with the distribution. 14 | 15 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 | ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 19 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 | OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 | OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 | SUCH DAMAGE. 26 | 27 | -------------------------------------------------------------------------------- /varnish.stub.php: -------------------------------------------------------------------------------- 1 | 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #include "varnish_lib.h" 32 | 33 | #ifndef PHP_VARNISH_EXCEPTION_H 34 | #define PHP_VARNISH_EXCEPTION_H 35 | 36 | enum { 37 | PHP_VARNISH_COMM_EXCEPTION = PHP_VARNISH_STATUS_COMMS, 38 | PHP_VARNISH_UNKNOWN_EXCEPTION = PHP_VARNISH_STATUS_UNKNOWN, 39 | PHP_VARNISH_UNIMPL_EXCEPTION = PHP_VARNISH_STATUS_UNIMPL, 40 | PHP_VARNISH_TOOFEW_EXCEPTION = PHP_VARNISH_STATUS_TOOFEW, 41 | PHP_VARNISH_TOOMANY_EXCEPTION = PHP_VARNISH_STATUS_TOOMANY, 42 | PHP_VARNISH_CANT_EXCEPTION = PHP_VARNISH_STATUS_CANT, 43 | PHP_VARNISH_PARAM_EXCEPTION = PHP_VARNISH_STATUS_PARAM, 44 | PHP_VARNISH_AUTH_EXCEPTION = PHP_VARNISH_STATUS_AUTH, 45 | PHP_VARNISH_SOCK_EXCEPTION = 1000, 46 | PHP_VARNISH_CONN_EXCEPTION, 47 | PHP_VARNISH_HANDSHAKE_EXCEPTION, 48 | PHP_VARNISH_TMO_EXCEPTION, 49 | PHP_VARNISH_SHM_EXCEPTION, 50 | PHP_VARNISH_COMPAT_EXCEPTION, 51 | }; 52 | 53 | void 54 | php_varnish_throw_comm_exception(TSRMLS_D); 55 | 56 | void 57 | php_varnish_throw_ident_vs_host_exception(TSRMLS_D); 58 | 59 | void 60 | php_varnish_throw_auth_exception(TSRMLS_D); 61 | 62 | void 63 | php_varnish_throw_conn_exception(TSRMLS_D); 64 | 65 | void 66 | php_varnish_throw_win_unimpl_exception(char *msg TSRMLS_DC); 67 | 68 | #endif /* PHP_VARNISH_EXCEPTION_H */ 69 | 70 | 71 | 72 | /* 73 | * Local variables: 74 | * tab-width: 4 75 | * c-basic-offset: 4 76 | * End: 77 | * vim600: noet sw=4 ts=4 fdm=marker 78 | * vim<600: noet sw=4 ts=4 79 | */ 80 | -------------------------------------------------------------------------------- /exception.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "php_varnish.h" 39 | #include "zend_exceptions.h" 40 | 41 | #include "exception.h" 42 | 43 | void 44 | php_varnish_throw_comm_exception(TSRMLS_D) 45 | { 46 | zend_throw_exception_ex( 47 | VarnishException_ce, 48 | PHP_VARNISH_COMM_EXCEPTION TSRMLS_CC, 49 | "Varnish communication error" 50 | ); 51 | } 52 | 53 | void 54 | php_varnish_throw_ident_vs_host_exception(TSRMLS_D) 55 | { 56 | zend_throw_exception_ex( 57 | VarnishException_ce, 58 | PHP_VARNISH_PARAM_EXCEPTION TSRMLS_CC, 59 | "Ident vs host/port configuration are mutually exclusive" 60 | ); 61 | } 62 | 63 | void 64 | php_varnish_throw_auth_exception(TSRMLS_D) 65 | { 66 | zend_throw_exception_ex( 67 | VarnishException_ce, 68 | PHP_VARNISH_AUTH_EXCEPTION TSRMLS_CC, 69 | "Not authenticated" 70 | ); 71 | } 72 | 73 | void 74 | php_varnish_throw_conn_exception(TSRMLS_D) 75 | { 76 | zend_throw_exception_ex( 77 | VarnishException_ce, 78 | PHP_VARNISH_CONN_EXCEPTION TSRMLS_CC, 79 | "Not connected to any varnish instance" 80 | ); 81 | } 82 | 83 | void 84 | php_varnish_throw_win_unimpl_exception(char *msg TSRMLS_DC) 85 | { 86 | zend_throw_exception_ex( 87 | VarnishException_ce, 88 | PHP_VARNISH_UNIMPL_EXCEPTION TSRMLS_CC, 89 | "%s", 90 | (NULL != msg) ? msg : "The functionality you're trying to use is not available on windows" 91 | ); 92 | } 93 | 94 | /* 95 | * Local variables: 96 | * tab-width: 4 97 | * c-basic-offset: 4 98 | * End: 99 | * vim600: noet sw=4 ts=4 fdm=marker 100 | * vim<600: noet sw=4 ts=4 101 | */ 102 | -------------------------------------------------------------------------------- /varnish_arginfo.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file, edit the .stub.php file instead. 2 | * Stub hash: 8f85af0f0ca3c73efcc24ed046662a4df80bf74f */ 3 | 4 | ZEND_BEGIN_ARG_INFO_EX(arginfo_class_VarnishAdmin___construct, 0, 0, 0) 5 | ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, opt, IS_ARRAY, 0, "[]") 6 | ZEND_END_ARG_INFO() 7 | 8 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_connect, 0, 0, _IS_BOOL, 0) 9 | ZEND_END_ARG_INFO() 10 | 11 | #define arginfo_class_VarnishAdmin_auth arginfo_class_VarnishAdmin_connect 12 | 13 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_getParams, 0, 0, IS_ARRAY, 0) 14 | ZEND_END_ARG_INFO() 15 | 16 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setParam, 0, 2, IS_LONG, 0) 17 | ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) 18 | ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0) 19 | ZEND_END_ARG_INFO() 20 | 21 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_stop, 0, 0, IS_LONG, 0) 22 | ZEND_END_ARG_INFO() 23 | 24 | #define arginfo_class_VarnishAdmin_start arginfo_class_VarnishAdmin_stop 25 | 26 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_banUrl, 0, 1, IS_LONG, 0) 27 | ZEND_ARG_TYPE_INFO(0, regex, IS_STRING, 0) 28 | ZEND_END_ARG_INFO() 29 | 30 | #define arginfo_class_VarnishAdmin_ban arginfo_class_VarnishAdmin_banUrl 31 | 32 | #define arginfo_class_VarnishAdmin_isRunning arginfo_class_VarnishAdmin_connect 33 | 34 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_getPanic, 0, 0, IS_STRING, 0) 35 | ZEND_END_ARG_INFO() 36 | 37 | #define arginfo_class_VarnishAdmin_clearPanic arginfo_class_VarnishAdmin_stop 38 | 39 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setHost, 0, 1, IS_VOID, 0) 40 | ZEND_ARG_TYPE_INFO(0, host, IS_STRING, 0) 41 | ZEND_END_ARG_INFO() 42 | 43 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setIdent, 0, 1, IS_VOID, 0) 44 | ZEND_ARG_TYPE_INFO(0, ident, IS_STRING, 0) 45 | ZEND_END_ARG_INFO() 46 | 47 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setSecret, 0, 1, IS_VOID, 0) 48 | ZEND_ARG_TYPE_INFO(0, secret, IS_STRING, 0) 49 | ZEND_END_ARG_INFO() 50 | 51 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setTimeout, 0, 1, IS_VOID, 0) 52 | ZEND_ARG_TYPE_INFO(0, timeout, IS_LONG, 0) 53 | ZEND_END_ARG_INFO() 54 | 55 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setPort, 0, 1, IS_VOID, 0) 56 | ZEND_ARG_TYPE_INFO(0, port, IS_LONG, 0) 57 | ZEND_END_ARG_INFO() 58 | 59 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_setCompat, 0, 1, IS_VOID, 0) 60 | ZEND_ARG_TYPE_INFO(0, compat, IS_LONG, 0) 61 | ZEND_END_ARG_INFO() 62 | 63 | #define arginfo_class_VarnishAdmin_getVclList arginfo_class_VarnishAdmin_getParams 64 | 65 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishAdmin_vclUse, 0, 1, _IS_BOOL, 0) 66 | ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) 67 | ZEND_END_ARG_INFO() 68 | 69 | #define arginfo_class_VarnishAdmin_disconnect arginfo_class_VarnishAdmin_connect 70 | 71 | #define arginfo_class_VarnishStat___construct arginfo_class_VarnishAdmin___construct 72 | 73 | #define arginfo_class_VarnishStat_getSnapshot arginfo_class_VarnishAdmin_getParams 74 | 75 | #define arginfo_class_VarnishLog___construct arginfo_class_VarnishAdmin___construct 76 | 77 | #define arginfo_class_VarnishLog_getLine arginfo_class_VarnishAdmin_getParams 78 | 79 | ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_VarnishLog_getTagName, 0, 1, IS_STRING, 0) 80 | ZEND_ARG_TYPE_INFO(0, ind, IS_LONG, 0) 81 | ZEND_END_ARG_INFO() 82 | -------------------------------------------------------------------------------- /config.m4: -------------------------------------------------------------------------------- 1 | PHP_ARG_WITH(varnish, for varnish support, 2 | [ --with-varnish Include varnish support]) 3 | 4 | if test "$PHP_VARNISH" != "no"; then 5 | 6 | AC_CHECK_HEADER(fcntl.h) 7 | AC_CHECK_HEADER(sys/types.h) 8 | AC_CHECK_HEADER(sys/socket.h) 9 | AC_CHECK_HEADER(netinet/in.h) 10 | AC_CHECK_HEADER(arpa/inet.h) 11 | AC_CHECK_HEADER(netdb.h) 12 | 13 | AC_PATH_PROG(PKG_CONFIG, pkg-config, no) 14 | if test -x "$PKG_CONFIG" && $PKG_CONFIG varnishapi --exists ; then 15 | dnl # rely on pkg-config available information 16 | AC_MSG_CHECKING(varnish version) 17 | if $PKG_CONFIG varnishapi --atleast-version=3 ; then 18 | VARNISH_INCLUDE=`$PKG_CONFIG varnishapi --cflags` 19 | VARNISH_LIBRARY=`$PKG_CONFIG varnishapi --libs` 20 | VARNISH_VERSION=`$PKG_CONFIG varnishapi --modversion` 21 | AC_MSG_RESULT($VARNISH_VERSION) 22 | 23 | PHP_EVAL_INCLINE($VARNISH_INCLUDE) 24 | PHP_EVAL_LIBLINE($VARNISH_LIBRARY, VARNISH_SHARED_LIBADD) 25 | if $PKG_CONFIG varnishapi --atleast-version=5.2 ; then 26 | AC_DEFINE(HAVE_VARNISHAPILIB,52,[ ]) 27 | elif $PKG_CONFIG varnishapi --atleast-version=5 ; then 28 | AC_DEFINE(HAVE_VARNISHAPILIB,50,[ ]) 29 | elif $PKG_CONFIG varnishapi --atleast-version=4.1 ; then 30 | AC_DEFINE(HAVE_VARNISHAPILIB,41,[ ]) 31 | elif $PKG_CONFIG varnishapi --atleast-version=4 ; then 32 | AC_DEFINE(HAVE_VARNISHAPILIB,40,[ ]) 33 | else 34 | AC_DEFINE(HAVE_VARNISHAPILIB,30,[ ]) 35 | fi 36 | AC_TYPE_UINTPTR_T 37 | AC_TYPE_UINT64_T 38 | else 39 | AC_MSG_RESULT(version too old) 40 | AC_MSG_ERROR(Please reinstall varnish version >= 3.0) 41 | fi 42 | else 43 | dnl # --with-varnish -> check with-path 44 | SEARCH_PATH="$PHP_VARNISH /usr/local /usr" 45 | SEARCH_FOR="varnishapi.h vcli.h" 46 | AC_MSG_CHECKING([for varnish files in default path]) 47 | for i in $SEARCH_PATH ; do 48 | for j in $SEARCH_FOR ; do 49 | if test -r $i/include/varnish/$j; then 50 | VARNISH_INCDIR=$i/include/varnish 51 | VARNISH_LIBDIR=$i/$PHP_LIBDIR 52 | break 53 | elif test -r $i/include/$j; then 54 | VARNISH_INCDIR=$i/include 55 | VARNISH_LIBDIR=$i/$PHP_LIBDIR 56 | break 57 | fi 58 | done 59 | done 60 | 61 | if test -z "$VARNISH_INCDIR"; then 62 | AC_MSG_RESULT([not found]) 63 | AC_MSG_ERROR([Please reinstall the varnish distribution]) 64 | else 65 | AC_MSG_RESULT(headers found in $VARNISH_INCDIR) 66 | fi 67 | 68 | PHP_ADD_INCLUDE($VARNISH_INCDIR) 69 | AC_CHECK_HEADER([$VARNISH_INCDIR/vcli.h], [], AC_MSG_ERROR('vcli.h' header not found)) 70 | 71 | LIBNAME=varnishapi 72 | LIBSYMBOL=VSM_New 73 | 74 | PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL, 75 | [ 76 | PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $VARNISH_LIBDIR, VARNISH_SHARED_LIBADD) 77 | 78 | if test -f $VARNISH_INCDIR/varnishapi.h; then 79 | dnl this is 3.x or earlier 80 | AC_DEFINE(HAVE_VARNISHAPILIB,30,[ ]) 81 | AC_CHECK_HEADER([$VARNISH_INCDIR/varnishapi.h], [], AC_MSG_ERROR('varnishapi.h' header not found)) 82 | AC_CHECK_HEADER([$VARNISH_INCDIR/vsl.h], [], AC_MSG_ERROR('vsl.h' header not found)) 83 | elif test -f $VARNISH_INCDIR/vapi/vsm.h; then 84 | dnl this is approx at least 4.1.x, for later will probably have to check for some specific stuff 85 | AC_DEFINE(HAVE_VARNISHAPILIB,41,[ ]) 86 | else 87 | dnl this is approx at least 4.x, for later will probably have to check for some specific stuff 88 | AC_DEFINE(HAVE_VARNISHAPILIB,40,[ ]) 89 | dnl there's an issue with two lines below, it might be because STLM macro isn't defined, 90 | dnl so the compiler decides them to be unusable 91 | dnl AC_CHECK_HEADER([$VARNISH_INCDIR/tbl/vsl_tags.h], [], AC_MSG_ERROR('tbl/vsl_tags.h' header not found)) 92 | dnl AC_CHECK_HEADER([$VARNISH_INCDIR/vapi/vsl.h], [], AC_MSG_ERROR('vapi/vsl.h' header not found)) 93 | fi 94 | AC_TYPE_UINTPTR_T 95 | AC_TYPE_UINT64_T 96 | ],[ 97 | AC_MSG_ERROR([wrong varnishapi lib version or lib not found]) 98 | ],[ 99 | -L$VARNISH_LIBDIR -lm 100 | ]) 101 | fi 102 | PHP_SUBST(VARNISH_SHARED_LIBADD) 103 | 104 | PHP_NEW_EXTENSION(varnish, varnish.c adm.c varnish_lib.c exception.c stat.c log.c, $ext_shared) 105 | PHP_ADD_EXTENSION_DEP(varnish, hash, true) 106 | 107 | fi 108 | -------------------------------------------------------------------------------- /php_varnish.h: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifndef PHP_VARNISH_H 32 | #define PHP_VARNISH_H 33 | 34 | extern zend_module_entry varnish_module_entry; 35 | #define phpext_varnish_ptr &varnish_module_entry 36 | 37 | #ifdef PHP_WIN32 38 | # define PHP_VARNISH_API __declspec(dllexport) 39 | #elif defined(__GNUC__) && __GNUC__ >= 4 40 | # define PHP_VARNISH_API __attribute__ ((visibility("default"))) 41 | #else 42 | # define PHP_VARNISH_API 43 | #endif 44 | 45 | #ifdef ZTS 46 | #include "TSRM.h" 47 | #endif 48 | 49 | #if PHP_MAJOR_VERSION < 7 50 | typedef long zend_long; 51 | #endif 52 | /*#define PHP_VARNISH_DEBUG*/ 53 | 54 | #define PHP_VARNISH_VERSION "1.2.7-dev" 55 | 56 | PHP_MINIT_FUNCTION(varnish); 57 | PHP_MSHUTDOWN_FUNCTION(varnish); 58 | PHP_RINIT_FUNCTION(varnish); 59 | PHP_RSHUTDOWN_FUNCTION(varnish); 60 | PHP_MINFO_FUNCTION(varnish); 61 | 62 | PHP_METHOD(VarnishAdmin, __construct); 63 | PHP_METHOD(VarnishAdmin, connect); 64 | PHP_METHOD(VarnishAdmin, auth); 65 | PHP_METHOD(VarnishAdmin, getParams); 66 | PHP_METHOD(VarnishAdmin, setParam); 67 | PHP_METHOD(VarnishAdmin, stop); 68 | PHP_METHOD(VarnishAdmin, start); 69 | PHP_METHOD(VarnishAdmin, banUrl); 70 | PHP_METHOD(VarnishAdmin, ban); 71 | PHP_METHOD(VarnishAdmin, isRunning); 72 | PHP_METHOD(VarnishAdmin, getPanic); 73 | PHP_METHOD(VarnishAdmin, clearPanic); 74 | PHP_METHOD(VarnishAdmin, setHost); 75 | PHP_METHOD(VarnishAdmin, setIdent); 76 | PHP_METHOD(VarnishAdmin, setPort); 77 | PHP_METHOD(VarnishAdmin, setTimeout); 78 | PHP_METHOD(VarnishAdmin, setSecret); 79 | PHP_METHOD(VarnishAdmin, setCompat); 80 | PHP_METHOD(VarnishAdmin, getVclList); 81 | PHP_METHOD(VarnishAdmin, vclUse); 82 | PHP_METHOD(VarnishAdmin, disconnect); 83 | 84 | PHP_METHOD(VarnishStat, __construct); 85 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 86 | PHP_METHOD(VarnishStat, getSnapshot); 87 | #endif 88 | 89 | PHP_METHOD(VarnishLog, __construct); 90 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 91 | PHP_METHOD(VarnishLog, getLine); 92 | PHP_METHOD(VarnishLog, getTagName); 93 | #endif 94 | 95 | /*ZEND_BEGIN_MODULE_GLOBALS(varnish) 96 | ZEND_END_MODULE_GLOBALS(varnish)*/ 97 | 98 | #ifdef ZTS 99 | #define VARNISH_G(v) TSRMG(varnish_globals_id, zend_varnish_globals *, v) 100 | #else 101 | #define VARNISH_G(v) (varnish_globals.v) 102 | #endif 103 | 104 | /*ZEND_EXTERN_MODULE_GLOBALS(varnish)*/ 105 | 106 | extern zend_class_entry *VarnishException_ce; 107 | 108 | #if PHP_MAJOR_VERSION >= 7 109 | extern zend_object *php_varnish_adm_obj_init(zend_class_entry *); 110 | extern zend_object *php_varnish_stat_obj_init(zend_class_entry *); 111 | extern zend_object *php_varnish_log_obj_init(zend_class_entry *); 112 | extern void php_varnish_adm_obj_destroy(zend_object *); 113 | extern void php_varnish_stat_obj_destroy(zend_object *); 114 | extern void php_varnish_log_obj_destroy(zend_object *); 115 | #else 116 | extern zend_object_value php_varnish_adm_obj_init(zend_class_entry *ze TSRMLS_DC); 117 | extern zend_object_value php_varnish_stat_obj_init(zend_class_entry *ze TSRMLS_DC); 118 | extern zend_object_value php_varnish_log_obj_init(zend_class_entry *ze TSRMLS_DC); 119 | #endif 120 | 121 | struct ze_varnish_conn { 122 | char *host; 123 | char *ident; 124 | char *secret; 125 | int host_len; 126 | int ident_len; 127 | int secret_len; 128 | int port; 129 | int timeout; 130 | int sock; 131 | int authok; 132 | }; 133 | 134 | #if PHP_MAJOR_VERSION >= 8 135 | #define TSRMLS_D void 136 | #define TSRMLS_DC 137 | #define TSRMLS_C 138 | #define TSRMLS_CC 139 | #define TSRMLS_FETCH() 140 | #endif 141 | 142 | #if PHP_MAJOR_VERSION >= 7 143 | struct ze_varnish_adm_obj { 144 | struct ze_varnish_conn zvc; 145 | int status; 146 | int compat; 147 | zend_object zo; 148 | }; 149 | 150 | struct ze_varnish_stat_obj { 151 | struct ze_varnish_conn zvc; 152 | zend_object zo; 153 | }; 154 | 155 | struct ze_varnish_log_obj { 156 | struct ze_varnish_conn zvc; 157 | struct VSM_data *vd; 158 | zend_object zo; 159 | }; 160 | 161 | static zend_always_inline struct ze_varnish_adm_obj * 162 | php_fetch_varnish_adm_obj(zend_object *obj) 163 | {/*{{{*/ 164 | return (struct ze_varnish_adm_obj *)((char *)obj - XtOffsetOf(struct ze_varnish_adm_obj, zo)); 165 | }/*}}}*/ 166 | static zend_always_inline struct ze_varnish_stat_obj * 167 | php_fetch_varnish_stat_obj(zend_object *obj) 168 | {/*{{{*/ 169 | return (struct ze_varnish_stat_obj *)((char *)obj - XtOffsetOf(struct ze_varnish_stat_obj, zo)); 170 | }/*}}}*/ 171 | static zend_always_inline struct ze_varnish_log_obj * 172 | php_fetch_varnish_log_obj(zend_object *obj) 173 | {/*{{{*/ 174 | return (struct ze_varnish_log_obj *)((char *)obj - XtOffsetOf(struct ze_varnish_log_obj, zo)); 175 | }/*}}}*/ 176 | #else 177 | struct ze_varnish_adm_obj { 178 | zend_object zo; 179 | struct ze_varnish_conn zvc; 180 | int status; 181 | int compat; 182 | }; 183 | 184 | struct ze_varnish_stat_obj { 185 | zend_object zo; 186 | struct ze_varnish_conn zvc; 187 | }; 188 | 189 | struct ze_varnish_log_obj { 190 | zend_object zo; 191 | struct ze_varnish_conn zvc; 192 | struct VSM_data *vd; 193 | }; 194 | #endif 195 | 196 | #endif /* PHP_VARNISH_H */ 197 | 198 | /* 199 | * Local variables: 200 | * tab-width: 4 201 | * c-basic-offset: 4 202 | * End: 203 | * vim600: noet sw=4 ts=4 fdm=marker 204 | * vim<600: noet sw=4 ts=4 205 | */ 206 | -------------------------------------------------------------------------------- /stat.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "zend_exceptions.h" 39 | #include "php_varnish.h" 40 | 41 | #include "varnish_lib.h" 42 | #include "exception.h" 43 | 44 | #if PHP_MAJOR_VERSION >= 7 45 | extern zend_object_handlers default_varnish_stat_handlers; 46 | #else 47 | extern zend_object_handlers default_varnish_handlers; 48 | #endif 49 | 50 | #if PHP_MAJOR_VERSION >= 7 51 | void 52 | php_varnish_stat_obj_destroy(zend_object *obj) 53 | {/*{{{*/ 54 | struct ze_varnish_stat_obj *zvso = php_fetch_varnish_stat_obj(obj); 55 | 56 | zend_object_std_dtor(&zvso->zo); 57 | 58 | if (zvso->zvc.ident_len > 0) { 59 | efree(zvso->zvc.ident); 60 | } 61 | }/*}}}*/ 62 | #else 63 | void 64 | php_varnish_stat_obj_destroy(void *obj TSRMLS_DC) 65 | {/*{{{*/ 66 | struct ze_varnish_stat_obj *zvso = (struct ze_varnish_stat_obj *)obj; 67 | 68 | zend_object_std_dtor(&zvso->zo TSRMLS_CC); 69 | 70 | if (zvso->zvc.ident_len > 0) { 71 | efree(zvso->zvc.ident); 72 | } 73 | 74 | efree(zvso); 75 | }/*}}}*/ 76 | #endif 77 | 78 | #if PHP_MAJOR_VERSION >= 7 79 | zend_object * 80 | php_varnish_stat_obj_init(zend_class_entry *ze) 81 | {/*{{{*/ 82 | struct ze_varnish_stat_obj *zvso; 83 | 84 | zvso = (struct ze_varnish_stat_obj *)ecalloc(1, sizeof(struct ze_varnish_stat_obj)); 85 | 86 | zend_object_std_init(&zvso->zo, ze); 87 | zvso->zo.handlers = &default_varnish_stat_handlers; 88 | 89 | zvso->zvc.ident = NULL; 90 | zvso->zvc.ident_len = 0; 91 | 92 | return &zvso->zo; 93 | }/*}}}*/ 94 | #else 95 | zend_object_value 96 | php_varnish_stat_obj_init(zend_class_entry *ze TSRMLS_DC) 97 | { /*{{{*/ 98 | zend_object_value ret; 99 | struct ze_varnish_stat_obj *zvso; 100 | #if PHP_VERSION_ID < 50399 101 | zval *tmp; 102 | #endif 103 | 104 | zvso = (struct ze_varnish_stat_obj*)emalloc(sizeof(struct ze_varnish_stat_obj)); 105 | memset(&zvso->zo, 0, sizeof(zend_object)); 106 | 107 | zend_object_std_init(&zvso->zo, ze TSRMLS_CC); 108 | #if PHP_VERSION_ID < 50399 109 | zend_hash_copy(zvso->zo.properties, &ze->default_properties, (copy_ctor_func_t) zval_add_ref, 110 | (void *) &tmp, sizeof(zval *)); 111 | #else 112 | object_properties_init(&zvso->zo, ze); 113 | #endif 114 | 115 | zvso->zvc.ident = NULL; 116 | zvso->zvc.ident_len = 0; 117 | 118 | ret.handle = zend_objects_store_put(zvso, NULL, 119 | (zend_objects_free_object_storage_t) php_varnish_stat_obj_destroy, 120 | NULL TSRMLS_CC); 121 | 122 | ret.handlers = &default_varnish_handlers; 123 | 124 | return ret; 125 | }/*}}}*/ 126 | #endif 127 | 128 | /* {{{ proto void VarnishStat::__construct(array options) 129 | * Varnish admin constructor */ 130 | PHP_METHOD(VarnishStat, __construct) 131 | { 132 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB >= 40 133 | php_varnish_throw_win_unimpl_exception("VarnishStat functionality isn't available for Varnish >= 4" TSRMLS_CC); 134 | return; 135 | #elif !defined(PHP_WIN32) 136 | struct ze_varnish_stat_obj *zvso; 137 | zval *opts = NULL; 138 | #if PHP_MAJOR_VERSION >= 7 139 | zval *ident; 140 | #else 141 | zval **ident; 142 | #endif 143 | 144 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &opts) == FAILURE) { 145 | return; 146 | } 147 | 148 | #if PHP_MAJOR_VERSION >= 7 149 | zvso = php_fetch_varnish_stat_obj(Z_OBJ_P(getThis())); 150 | #else 151 | zvso = (struct ze_varnish_stat_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 152 | #endif 153 | 154 | if (NULL == opts) { 155 | php_varnish_default_ident(&zvso->zvc.ident, (int*)&zvso->zvc.ident_len); 156 | return; 157 | } 158 | 159 | #if PHP_MAJOR_VERSION >= 7 160 | if((ident = zend_hash_find(Z_ARRVAL_P(opts), zend_string_init("ident", sizeof("ident")-1, 0))) != NULL) { 161 | convert_to_string(ident); 162 | zvso->zvc.ident = estrdup(Z_STRVAL_P(ident)); 163 | zvso->zvc.ident_len = Z_STRLEN_P(ident); 164 | } else { 165 | php_varnish_default_ident(&zvso->zvc.ident, (int*)&zvso->zvc.ident_len); 166 | } 167 | #else 168 | if(zend_hash_find(Z_ARRVAL_P(opts), "ident", sizeof("ident"), (void**)&ident) != FAILURE) { 169 | convert_to_string(*ident); 170 | zvso->zvc.ident = estrdup(Z_STRVAL_PP(ident)); 171 | zvso->zvc.ident_len = Z_STRLEN_PP(ident); 172 | } else { 173 | php_varnish_default_ident(&zvso->zvc.ident, (int*)&zvso->zvc.ident_len); 174 | } 175 | #endif 176 | 177 | #else 178 | php_varnish_throw_win_unimpl_exception("VarnishStat functionality isn't available on windows" TSRMLS_CC); 179 | return; 180 | #endif 181 | } 182 | /* }}} */ 183 | 184 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 185 | /* {{{ proto array VarnishStat::getSnapshot(void) 186 | Get a statistics snapshot */ 187 | PHP_METHOD(VarnishStat, getSnapshot) 188 | { 189 | struct ze_varnish_stat_obj *zvso; 190 | 191 | if (zend_parse_parameters_none() == FAILURE) { 192 | return; 193 | } 194 | 195 | #if PHP_MAJOR_VERSION >= 7 196 | zvso = php_fetch_varnish_stat_obj(Z_OBJ_P(getThis())); 197 | #else 198 | zvso = (struct ze_varnish_stat_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 199 | #endif 200 | 201 | /* Ensure the ctor was called properly and we have an ident to connect to */ 202 | if (!zvso->zvc.ident) { 203 | zend_throw_exception_ex( 204 | VarnishException_ce, 205 | PHP_VARNISH_COMM_EXCEPTION TSRMLS_CC, 206 | "Missing ident to connect to" 207 | ); 208 | return; 209 | } 210 | 211 | array_init(return_value); 212 | (void)php_varnish_snap_stats(return_value, zvso->zvc.ident TSRMLS_CC); 213 | } 214 | /* }}} */ 215 | #endif 216 | 217 | /* 218 | * Local variables: 219 | * tab-width: 4 220 | * c-basic-offset: 4 221 | * End: 222 | * vim600: noet sw=4 ts=4 fdm=marker 223 | * vim<600: noet sw=4 ts=4 224 | */ 225 | -------------------------------------------------------------------------------- /log.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "zend_exceptions.h" 39 | #include "php_varnish.h" 40 | 41 | #include "varnish_lib.h" 42 | #include "exception.h" 43 | 44 | 45 | #if PHP_MAJOR_VERSION >= 7 46 | extern zend_object_handlers default_varnish_log_handlers; 47 | #else 48 | extern zend_object_handlers default_varnish_handlers; 49 | #endif 50 | 51 | #if PHP_MAJOR_VERSION >= 7 52 | void 53 | php_varnish_log_obj_destroy(zend_object *obj) 54 | {/*{{{*/ 55 | struct ze_varnish_log_obj *zvlo = php_fetch_varnish_log_obj(obj); 56 | 57 | zend_object_std_dtor(&zvlo->zo); 58 | 59 | if (zvlo->zvc.ident_len > 0) { 60 | efree(zvlo->zvc.ident); 61 | } 62 | 63 | if (zvlo->vd) { 64 | zvlo->vd = NULL; 65 | } 66 | }/*}}}*/ 67 | #else 68 | void 69 | php_varnish_log_obj_destroy(void *obj TSRMLS_DC) 70 | {/*{{{*/ 71 | struct ze_varnish_log_obj *zvlo = (struct ze_varnish_log_obj *)obj; 72 | 73 | zend_object_std_dtor(&zvlo->zo TSRMLS_CC); 74 | 75 | if (zvlo->zvc.ident_len > 0) { 76 | efree(zvlo->zvc.ident); 77 | } 78 | 79 | if (zvlo->vd) { 80 | zvlo->vd = NULL; 81 | } 82 | 83 | efree(zvlo); 84 | }/*}}}*/ 85 | #endif 86 | 87 | #if PHP_MAJOR_VERSION >= 7 88 | zend_object * 89 | php_varnish_log_obj_init(zend_class_entry *ze) 90 | {/*{{{*/ 91 | struct ze_varnish_log_obj *zvlo; 92 | 93 | zvlo = (struct ze_varnish_log_obj *)ecalloc(1, sizeof(struct ze_varnish_log_obj)); 94 | 95 | zend_object_std_init(&zvlo->zo, ze); 96 | zvlo->zo.handlers = &default_varnish_log_handlers; 97 | 98 | zvlo->zvc.ident = NULL; 99 | zvlo->zvc.ident_len = 0; 100 | zvlo->vd = NULL; 101 | 102 | return &zvlo->zo; 103 | }/*}}}*/ 104 | #else 105 | zend_object_value 106 | php_varnish_log_obj_init(zend_class_entry *ze TSRMLS_DC) 107 | { /*{{{*/ 108 | zend_object_value ret; 109 | struct ze_varnish_log_obj *zvlo; 110 | #if PHP_VERSION_ID < 50399 111 | zval *tmp; 112 | #endif 113 | 114 | zvlo = (struct ze_varnish_log_obj*)emalloc(sizeof(struct ze_varnish_log_obj)); 115 | memset(&zvlo->zo, 0, sizeof(zend_object)); 116 | 117 | zend_object_std_init(&zvlo->zo, ze TSRMLS_CC); 118 | #if PHP_VERSION_ID < 50399 119 | zend_hash_copy(zvlo->zo.properties, &ze->default_properties, (copy_ctor_func_t) zval_add_ref, 120 | (void *) &tmp, sizeof(zval *)); 121 | #else 122 | object_properties_init(&zvlo->zo, ze); 123 | #endif 124 | 125 | zvlo->zvc.ident = NULL; 126 | zvlo->zvc.ident_len = 0; 127 | zvlo->vd = NULL; 128 | 129 | ret.handle = zend_objects_store_put(zvlo, NULL, 130 | (zend_objects_free_object_storage_t) php_varnish_log_obj_destroy, 131 | NULL TSRMLS_CC); 132 | 133 | ret.handlers = &default_varnish_handlers; 134 | 135 | return ret; 136 | }/*}}}*/ 137 | #endif 138 | 139 | /* {{{ proto void VarnishLog::__construct(array options) 140 | * Varnish admin constructor */ 141 | PHP_METHOD(VarnishLog, __construct) 142 | { 143 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB >= 40 144 | php_varnish_throw_win_unimpl_exception("VarnishLog functionality isn't available for Varnish >= 4" TSRMLS_CC); 145 | return; 146 | #elif !defined(PHP_WIN32) 147 | struct ze_varnish_log_obj *zvlo; 148 | zval *opts = NULL, **ident; 149 | 150 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &opts) == FAILURE) { 151 | return; 152 | } 153 | 154 | #if PHP_MAJOR_VERSION >= 7 155 | zvlo = php_fetch_varnish_log_obj(Z_OBJ_P(getThis())); 156 | #else 157 | zvlo = (struct ze_varnish_log_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 158 | #endif 159 | 160 | if (NULL == opts) { 161 | php_varnish_default_ident(&zvlo->zvc.ident, (int*)&zvlo->zvc.ident_len); 162 | } else { 163 | #if PHP_MAJOR_VERSION >= 7 164 | zval *ident; 165 | 166 | if((ident = zend_hash_find(Z_ARRVAL_P(opts), zend_string_init("ident", sizeof("ident")-1, 0))) != NULL) { 167 | convert_to_string(ident); 168 | zvlo->zvc.ident = estrdup(Z_STRVAL_P(ident)); 169 | zvlo->zvc.ident_len = Z_STRLEN_P(ident); 170 | } else { 171 | php_varnish_default_ident(&zvlo->zvc.ident, (int*)&zvlo->zvc.ident_len); 172 | } 173 | #else 174 | zval **ident; 175 | 176 | if(zend_hash_find(Z_ARRVAL_P(opts), "ident", sizeof("ident"), (void**)&ident) != FAILURE) { 177 | convert_to_string(*ident); 178 | zvlo->zvc.ident = estrdup(Z_STRVAL_PP(ident)); 179 | zvlo->zvc.ident_len = Z_STRLEN_PP(ident); 180 | } else { 181 | php_varnish_default_ident(&zvlo->zvc.ident, (int*)&zvlo->zvc.ident_len); 182 | } 183 | #endif 184 | } 185 | 186 | zvlo->vd = VSM_New(); 187 | VSL_Setup(zvlo->vd); 188 | 189 | if (zvlo->zvc.ident_len > 0) { 190 | if (-1 == VSL_Arg(zvlo->vd, 'n', zvlo->zvc.ident)) { 191 | zend_throw_exception_ex( 192 | VarnishException_ce, 193 | PHP_VARNISH_UNKNOWN_EXCEPTION TSRMLS_CC, 194 | "Failed to handle the ident" 195 | ); 196 | } 197 | } 198 | 199 | if (VSL_Open(zvlo->vd, 1)) { 200 | zend_throw_exception_ex( 201 | VarnishException_ce, 202 | PHP_VARNISH_CANT_EXCEPTION TSRMLS_CC, 203 | "Could not open shared log" 204 | ); 205 | 206 | return; 207 | } 208 | #else 209 | php_varnish_throw_win_unimpl_exception("VarnishLog functionality isn't available on windows" TSRMLS_CC); 210 | return; 211 | #endif 212 | } 213 | /* }}} */ 214 | 215 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 216 | /* {{{ proto array VarnishLog::getLine(void) 217 | * Get the next log entry */ 218 | PHP_METHOD(VarnishLog, getLine) 219 | { 220 | struct ze_varnish_log_obj *zvlo; 221 | 222 | if (zend_parse_parameters_none() == FAILURE) { 223 | return; 224 | } 225 | 226 | #if PHP_MAJOR_VERSION >= 7 227 | zvlo = php_fetch_varnish_log_obj(Z_OBJ_P(getThis())); 228 | #else 229 | zvlo = (struct ze_varnish_log_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 230 | #endif 231 | 232 | array_init(return_value); 233 | (void)php_varnish_get_log(zvlo->vd, return_value TSRMLS_CC); 234 | } 235 | /* }}} */ 236 | 237 | 238 | /* {{{ proto string VarnishLog::getTagName(int index) 239 | Get tag name by its numerical index */ 240 | PHP_METHOD(VarnishLog, getTagName) 241 | { 242 | char *ret; 243 | zend_long ind; 244 | int ret_len; 245 | 246 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ind) == FAILURE) { 247 | return; 248 | } 249 | 250 | php_varnish_log_get_tag_name((int)ind, &ret, &ret_len TSRMLS_CC); 251 | 252 | #if PHP_MAJOR_VERSION >= 7 253 | RETURN_STRINGL(ret, ret_len); 254 | #else 255 | RETURN_STRINGL(ret, ret_len, 0); 256 | #endif 257 | } 258 | /* }}} */ 259 | #endif 260 | 261 | /* 262 | * Local variables: 263 | * tab-width: 4 264 | * c-basic-offset: 4 265 | * End: 266 | * vim600: noet sw=4 ts=4 fdm=marker 267 | * vim<600: noet sw=4 ts=4 268 | */ 269 | -------------------------------------------------------------------------------- /varnish_lib.h: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifndef PHP_VARNISH_LIB_H 32 | #define PHP_VARNISH_LIB_H 33 | 34 | #if HAVE_STDINT_H 35 | #include 36 | #endif 37 | 38 | #ifndef PHP_WIN32 39 | #if HAVE_VARNISHAPILIB >= 41 40 | #include 41 | #endif 42 | #if HAVE_VARNISHAPILIB >= 40 43 | #include 44 | #include 45 | #include 46 | #include 47 | #else 48 | #include 49 | #include 50 | #include 51 | #endif 52 | #endif 53 | 54 | /* get socket connection */ 55 | int 56 | php_varnish_sock(const char *addr, int port, int timeout, int *status TSRMLS_DC); 57 | #ifndef PHP_WIN32 58 | int 59 | php_varnish_sock_ident(const char *ident, char **addr, int *addr_len, int *port, int timeout, int *status TSRMLS_DC); 60 | #endif 61 | 62 | void 63 | php_varnish_default_ident(char **ident, int *ident_len); 64 | 65 | /* authenticate with the varnish instance running under the given socket */ 66 | int 67 | php_varnish_auth(int sock, char *secret, int secret_len, int *status, int timeout TSRMLS_DC); 68 | #ifndef PHP_WIN32 69 | int 70 | php_varnish_auth_ident(int sock, const char *ident, int timeout, int *status TSRMLS_DC); 71 | #endif 72 | 73 | int 74 | php_varnish_get_params(int sock, int *status, zval *storage, int timeout TSRMLS_DC); 75 | 76 | int 77 | php_varnish_set_param(int sock, int *status, char *key, int key_len, char *param, int param_len, int timeout TSRMLS_DC); 78 | 79 | int 80 | php_varnish_start(int sock, int *status, int timeout TSRMLS_DC); 81 | 82 | int 83 | php_varnish_stop(int sock, int *status, int timeout TSRMLS_DC); 84 | 85 | int 86 | php_varnish_ban(int sock, int *status, char *reg, int reg_len, int timeout, int type, int compat TSRMLS_DC); 87 | 88 | #ifndef PHP_WIN32 89 | int 90 | php_varnish_snap_stats(zval *storage, const char *ident TSRMLS_DC); 91 | #endif 92 | 93 | int 94 | php_varnish_is_running(int sock, int *status, int timeout TSRMLS_DC); 95 | 96 | int 97 | php_varnish_get_panic(int sock, int *status, char **msg, int *msg_len, int tmo TSRMLS_DC); 98 | 99 | int 100 | php_varnish_clear_panic(int sock, int *status, int tmo TSRMLS_DC); 101 | 102 | #ifndef PHP_WIN32 103 | #if HAVE_VARNISHAPILIB >= 52 104 | int 105 | php_varnish_get_log(const struct vsm *vd, zval *line TSRMLS_DC); 106 | #else 107 | int 108 | php_varnish_get_log(const struct VSM_data *vd, zval *line TSRMLS_DC); 109 | #endif 110 | 111 | void 112 | php_varnish_log_get_tag_name(int index, char **ret, int *ret_len TSRMLS_DC); 113 | #endif 114 | 115 | int 116 | php_varnish_adm_can_go(struct ze_varnish_adm_obj *zvao TSRMLS_DC); 117 | 118 | int 119 | php_varnish_check_compat(int version TSRMLS_DC); 120 | 121 | int 122 | php_varnish_get_vcl_list(int sock, int *status, int tmo, zval *ret TSRMLS_DC); 123 | 124 | int 125 | php_varnish_vcl_use(int sock, int *status, int tmo, char *vcl_name, int vcl_name_len TSRMLS_DC); 126 | 127 | /* First response line length including '\0' */ 128 | #ifdef PHP_WIN32 129 | #define PHP_VARNISH_LINE0_MAX_LEN 13 130 | #else 131 | #define PHP_VARNISH_LINE0_MAX_LEN CLI_LINE0_LEN 132 | #endif 133 | 134 | /* Challenge string length */ 135 | #define PHP_VARNISH_CHALLENGE_LEN 32 136 | 137 | /* {{{ Status/return codes in the varnish CLI protocol 138 | */ 139 | #ifndef PHP_WIN32 140 | #define PHP_VARNISH_STATUS_SYNTAX CLIS_SYNTAX 141 | #define PHP_VARNISH_STATUS_UNKNOWN CLIS_UNKNOWN 142 | #define PHP_VARNISH_STATUS_UNIMPL CLIS_UNIMPL 143 | #define PHP_VARNISH_STATUS_TOOFEW CLIS_TOOFEW 144 | #define PHP_VARNISH_STATUS_TOOMANY CLIS_TOOMANY 145 | #define PHP_VARNISH_STATUS_PARAM CLIS_PARAM 146 | #define PHP_VARNISH_STATUS_AUTH CLIS_AUTH 147 | #define PHP_VARNISH_STATUS_OK CLIS_OK 148 | #define PHP_VARNISH_STATUS_CANT CLIS_CANT 149 | #define PHP_VARNISH_STATUS_COMMS CLIS_COMMS 150 | #define PHP_VARNISH_STATUS_CLOSE CLIS_CLOSE 151 | #else 152 | #define PHP_VARNISH_STATUS_SYNTAX 100 153 | #define PHP_VARNISH_STATUS_UNKNOWN 101 154 | #define PHP_VARNISH_STATUS_UNIMPL 102 155 | #define PHP_VARNISH_STATUS_TOOFEW 104 156 | #define PHP_VARNISH_STATUS_TOOMANY 105 157 | #define PHP_VARNISH_STATUS_PARAM 106 158 | #define PHP_VARNISH_STATUS_AUTH 107 159 | #define PHP_VARNISH_STATUS_OK 200 160 | #define PHP_VARNISH_STATUS_CANT 300 161 | #define PHP_VARNISH_STATUS_COMMS 400 162 | #define PHP_VARNISH_STATUS_CLOSE 500 /*}}}*/ 163 | #endif 164 | 165 | /*{{{ varnish param names */ 166 | #define PHP_VARNISH_PARAM_ACCEPT_FILTER "accept_filter" 167 | #define PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_DECAY "acceptor_sleep_decay" 168 | #define PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_INCR "acceptor_sleep_incr" 169 | #define PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_MAX "acceptor_sleep_max" 170 | #define PHP_VARNISH_PARAM_AUTO_RESTART "auto_restart" 171 | #define PHP_VARNISH_PARAM_BAN_DUPS "ban_dups" 172 | #define PHP_VARNISH_PARAM_BAN_LURKER_SLEEP "ban_lurker_sleep" 173 | #define PHP_VARNISH_PARAM_BETWEEN_BYTES_TIMEOUT "between_bytes_timeout" 174 | #define PHP_VARNISH_PARAM_CC_COMMAND "cc_command" 175 | #define PHP_VARNISH_PARAM_CLI_BUFFER "cli_buffer" 176 | #define PHP_VARNISH_PARAM_CLI_TIMEOUT "cli_timeout" 177 | #define PHP_VARNISH_PARAM_CLOCK_SKEW "clock_skew" 178 | #define PHP_VARNISH_PARAM_CONNECT_TIMEOUT "connect_timeout" 179 | #define PHP_VARNISH_PARAM_CRITBIT_COOLOFF "critbit_cooloff" 180 | #define PHP_VARNISH_PARAM_DEFAULT_GRACE "default_grace" 181 | #define PHP_VARNISH_PARAM_DEFAULT_KEEP "default_keep" 182 | #define PHP_VARNISH_PARAM_DEFAULT_TTL "default_ttl" 183 | #define PHP_VARNISH_PARAM_DIAG_BITMAP "diag_bitmap" 184 | #define PHP_VARNISH_PARAM_ESI_SYNTAX "esi_syntax" 185 | #define PHP_VARNISH_PARAM_EXPIRY_SLEEP "expiry_sleep" 186 | #define PHP_VARNISH_PARAM_FETCH_CHUNKSIZE "fetch_chunksize" 187 | #define PHP_VARNISH_PARAM_FETCH_MAXCHUNKSIZE "fetch_maxchunksize" 188 | #define PHP_VARNISH_PARAM_FIRST_BYTE_TIMEOUT "first_byte_timeout" 189 | #define PHP_VARNISH_PARAM_GROUP "group" 190 | #define PHP_VARNISH_PARAM_GZIP_LEVEL "gzip_level" 191 | #define PHP_VARNISH_PARAM_GZIP_STACK_BUFFER "gzip_stack_buffer" 192 | #define PHP_VARNISH_PARAM_GZIP_TMP_SPACE "gzip_tmp_space" 193 | #define PHP_VARNISH_PARAM_HTTP_GZIP_SUPPORT "http_gzip_support" 194 | #define PHP_VARNISH_PARAM_HTTP_MAX_HDR "http_max_hdr" 195 | #define PHP_VARNISH_PARAM_HTTP_RANGE_SUPPORT "http_range_support" 196 | #define PHP_VARNISH_PARAM_HTTP_REQ_HDR_LEN "http_req_hdr_len" 197 | #define PHP_VARNISH_PARAM_HTTP_REQ_SIZE "http_req_size" 198 | #define PHP_VARNISH_PARAM_HTTP_RESP_HDR_LEN "http_resp_hdr_len" 199 | #define PHP_VARNISH_PARAM_HTTP_RESP_SIZE "http_resp_size" 200 | #define PHP_VARNISH_PARAM_LISTEN_ADDRESS "listen_address" 201 | #define PHP_VARNISH_PARAM_LISTEN_DEPTH "listen_depth" 202 | #define PHP_VARNISH_PARAM_LOG_HASHSTRING "log_hashstring" 203 | #define PHP_VARNISH_PARAM_LOG_LOCAL_ADDRESS "log_local_address" 204 | #define PHP_VARNISH_PARAM_LRU_INTERVAL "lru_interval" 205 | #define PHP_VARNISH_PARAM_MAX_ESI_DEPTH "max_esi_depth" 206 | #define PHP_VARNISH_PARAM_MAX_RESTARTS "max_restarts" 207 | #define PHP_VARNISH_PARAM_PING_INTERVAL "ping_interval" 208 | #define PHP_VARNISH_PARAM_PIPE_TIMEOUT "pipe_timeout" 209 | #define PHP_VARNISH_PARAM_PREFER_IPV6 "prefer_ipv6" 210 | #define PHP_VARNISH_PARAM_QUEUE_MAX "queue_max" 211 | #define PHP_VARNISH_PARAM_RUSH_EXPONENT "rush_exponent" 212 | #define PHP_VARNISH_PARAM_SAINTMODE_THRESHOLD "saintmode_threshold" 213 | #define PHP_VARNISH_PARAM_SEND_TIMEOUT "send_timeout" 214 | #define PHP_VARNISH_PARAM_SESS_TIMEOUT "sess_timeout" 215 | #define PHP_VARNISH_PARAM_SESS_WORKSPACE "sess_workspace" 216 | #define PHP_VARNISH_PARAM_SESSION_LINGER "session_linger" 217 | #define PHP_VARNISH_PARAM_SESSION_MAX "session_max" 218 | #define PHP_VARNISH_PARAM_SHM_RECLEN "shm_reclen" 219 | #define PHP_VARNISH_PARAM_SHM_WORKSPACE "shm_workspace" 220 | #define PHP_VARNISH_PARAM_SHORTLIVED "shortlived" 221 | #define PHP_VARNISH_PARAM_SYSLOG_CLI_TRAFFIC "syslog_cli_traffic" 222 | #define PHP_VARNISH_PARAM_THREAD_POOL_ADD_DELAY "thread_pool_add_delay" 223 | #define PHP_VARNISH_PARAM_THREAD_POOL_ADD_THRESHOLD "thread_pool_add_threshold" 224 | #define PHP_VARNISH_PARAM_THREAD_POOL_FAIL_DELAY "thread_pool_fail_delay" 225 | #define PHP_VARNISH_PARAM_THREAD_POOL_MAX "thread_pool_max" 226 | #define PHP_VARNISH_PARAM_THREAD_POOL_MIN "thread_pool_min" 227 | #define PHP_VARNISH_PARAM_THREAD_POOL_PURGE_DELAY "thread_pool_purge_delay" 228 | #define PHP_VARNISH_PARAM_THREAD_POOL_STACK "thread_pool_stack" 229 | #define PHP_VARNISH_PARAM_THREAD_POOL_TIMEOUT "thread_pool_timeout" 230 | #define PHP_VARNISH_PARAM_THREAD_POOL_WORKSPACE "thread_pool_workspace" 231 | #define PHP_VARNISH_PARAM_THREAD_POOLS "thread_pools" 232 | #define PHP_VARNISH_PARAM_THREAD_STATS_RATE "thread_stats_rate" 233 | #define PHP_VARNISH_PARAM_USER "user" 234 | #define PHP_VARNISH_PARAM_VCC_ERR_UNREF "vcc_err_unref" 235 | #define PHP_VARNISH_PARAM_VCL_DIR "vcl_dir" 236 | #define PHP_VARNISH_PARAM_VCL_TRACE "vcl_trace" 237 | #define PHP_VARNISH_PARAM_VMOD_DIR "vmod_dir" 238 | #define PHP_VARNISH_PARAM_WAITER "waiter"/*}}}*/ 239 | 240 | enum { 241 | PHP_VARNISH_PARAM_STRING, 242 | PHP_VARNISH_PARAM_DOUBLE, 243 | PHP_VARNISH_PARAM_INT, 244 | PHP_VARNISH_PARAM_BOOL, 245 | PHP_VARNISH_PARAM_QUOTED_STRING, 246 | }; 247 | 248 | struct php_varnish_param { 249 | char *param_name; 250 | int param_type; 251 | }; 252 | 253 | enum { 254 | PHP_VARNISH_BAN_COMMAND, 255 | PHP_VARNISH_BAN_URL_COMMAND, 256 | }; 257 | 258 | enum { 259 | PHP_VARNISH_COMPAT_2 = 2, 260 | PHP_VARNISH_COMPAT_3 = 3, 261 | PHP_VARNISH_COMPAT_4 = 4, 262 | }; 263 | 264 | #endif /* PHP_VARNISH_LIB_H */ 265 | 266 | /* 267 | * Local variables: 268 | * tab-width: 4 269 | * c-basic-offset: 4 270 | * End: 271 | * vim600: noet sw=4 ts=4 fdm=marker 272 | * vim<600: noet sw=4 ts=4 273 | */ 274 | -------------------------------------------------------------------------------- /varnish.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "zend_exceptions.h" 39 | #include "php_varnish.h" 40 | 41 | #include "varnish_lib.h" 42 | 43 | /* Compatibility with PHP < 8 */ 44 | #if PHP_VERSION_ID < 70200 45 | #undef ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX 46 | #endif 47 | 48 | #ifndef ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX 49 | #define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \ 50 | ZEND_BEGIN_ARG_INFO_EX(name, 0, return_reference, required_num_args) 51 | #endif 52 | 53 | #ifndef ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE 54 | #define ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, type_hint, allow_null, default_value) \ 55 | ZEND_ARG_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) 56 | #endif 57 | 58 | /* Arginfo generated with PHP 8 */ 59 | #include "varnish_arginfo.h" 60 | 61 | /*ZEND_DECLARE_MODULE_GLOBALS(varnish)*/ 62 | 63 | /* True global resources - no need for thread safety here 64 | static int le_varnish; 65 | */ 66 | 67 | /* Class entry definition */ 68 | zend_class_entry *VarnishAdmin_ce; 69 | zend_class_entry *VarnishStat_ce; 70 | zend_class_entry *VarnishLog_ce; 71 | zend_class_entry *VarnishException_ce; 72 | 73 | #if PHP_MAJOR_VERSION >= 7 74 | zend_object_handlers default_varnish_adm_handlers; 75 | zend_object_handlers default_varnish_log_handlers; 76 | zend_object_handlers default_varnish_stat_handlers; 77 | #else 78 | zend_object_handlers default_varnish_handlers; 79 | #endif 80 | 81 | /* {{{ varnish_functions[] 82 | */ 83 | const zend_function_entry varnish_functions[] = { 84 | {NULL, NULL, NULL} 85 | }; 86 | /* }}} */ 87 | 88 | /* {{{ VarnishAdmin_methods[] 89 | */ 90 | const zend_function_entry VarnishAdmin_methods[] = { 91 | PHP_ME(VarnishAdmin, __construct, arginfo_class_VarnishAdmin___construct, ZEND_ACC_PUBLIC) 92 | PHP_ME(VarnishAdmin, connect, arginfo_class_VarnishAdmin_connect, ZEND_ACC_PUBLIC) 93 | PHP_ME(VarnishAdmin, auth, arginfo_class_VarnishAdmin_auth, ZEND_ACC_PUBLIC) 94 | PHP_ME(VarnishAdmin, getParams, arginfo_class_VarnishAdmin_getParams, ZEND_ACC_PUBLIC) 95 | PHP_ME(VarnishAdmin, setParam, arginfo_class_VarnishAdmin_setParam, ZEND_ACC_PUBLIC) 96 | PHP_ME(VarnishAdmin, stop, arginfo_class_VarnishAdmin_stop, ZEND_ACC_PUBLIC) 97 | PHP_ME(VarnishAdmin, start, arginfo_class_VarnishAdmin_start, ZEND_ACC_PUBLIC) 98 | PHP_ME(VarnishAdmin, banUrl, arginfo_class_VarnishAdmin_banUrl, ZEND_ACC_PUBLIC) 99 | PHP_ME(VarnishAdmin, ban, arginfo_class_VarnishAdmin_ban, ZEND_ACC_PUBLIC) 100 | PHP_ME(VarnishAdmin, isRunning, arginfo_class_VarnishAdmin_isRunning, ZEND_ACC_PUBLIC) 101 | PHP_ME(VarnishAdmin, getPanic, arginfo_class_VarnishAdmin_getPanic, ZEND_ACC_PUBLIC) 102 | PHP_ME(VarnishAdmin, clearPanic, arginfo_class_VarnishAdmin_clearPanic, ZEND_ACC_PUBLIC) 103 | PHP_ME(VarnishAdmin, setHost, arginfo_class_VarnishAdmin_setHost, ZEND_ACC_PUBLIC) 104 | PHP_ME(VarnishAdmin, setIdent, arginfo_class_VarnishAdmin_setIdent, ZEND_ACC_PUBLIC) 105 | PHP_ME(VarnishAdmin, setTimeout, arginfo_class_VarnishAdmin_setTimeout, ZEND_ACC_PUBLIC) 106 | PHP_ME(VarnishAdmin, setPort, arginfo_class_VarnishAdmin_setPort, ZEND_ACC_PUBLIC) 107 | PHP_ME(VarnishAdmin, setSecret, arginfo_class_VarnishAdmin_setSecret, ZEND_ACC_PUBLIC) 108 | PHP_ME(VarnishAdmin, setCompat, arginfo_class_VarnishAdmin_setCompat, ZEND_ACC_PUBLIC) 109 | PHP_ME(VarnishAdmin, getVclList, arginfo_class_VarnishAdmin_getVclList, ZEND_ACC_PUBLIC) 110 | PHP_ME(VarnishAdmin, vclUse, arginfo_class_VarnishAdmin_vclUse, ZEND_ACC_PUBLIC) 111 | PHP_ME(VarnishAdmin, disconnect, arginfo_class_VarnishAdmin_disconnect, ZEND_ACC_PUBLIC) 112 | {NULL, NULL, NULL} 113 | }; 114 | /* }}} */ 115 | 116 | /* {{{ VarnishStat_methods{} */ 117 | const zend_function_entry VarnishStat_methods[] = { 118 | PHP_ME(VarnishStat, __construct, arginfo_class_VarnishStat___construct, ZEND_ACC_PUBLIC) 119 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 120 | PHP_ME(VarnishStat, getSnapshot, arginfo_class_VarnishStat_getSnapshot, ZEND_ACC_PUBLIC) 121 | #endif 122 | {NULL, NULL, NULL} 123 | }; 124 | /* }}} */ 125 | 126 | /* {{{ VarnishLog_methods{} */ 127 | const zend_function_entry VarnishLog_methods[] = { 128 | PHP_ME(VarnishLog, __construct, arginfo_class_VarnishLog___construct, ZEND_ACC_PUBLIC) 129 | #if defined(HAVE_VARNISHAPILIB) && HAVE_VARNISHAPILIB < 40 130 | PHP_ME(VarnishLog, getLine, arginfo_class_VarnishLog_getLine, ZEND_ACC_PUBLIC) 131 | PHP_ME(VarnishLog, getTagName, arginfo_class_VarnishLog_getTagName, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) 132 | #endif 133 | {NULL, NULL, NULL} 134 | }; 135 | /* }}} */ 136 | 137 | /* {{{ varnish_deps */ 138 | static const zend_module_dep varnish_deps[] = { 139 | ZEND_MOD_REQUIRED("hash") 140 | {NULL, NULL, NULL} 141 | };/*}}}*/ 142 | 143 | /* {{{ varnish_module_entry 144 | */ 145 | zend_module_entry varnish_module_entry = { 146 | STANDARD_MODULE_HEADER_EX, 147 | NULL, 148 | varnish_deps, 149 | "varnish", 150 | varnish_functions, 151 | PHP_MINIT(varnish), 152 | PHP_MSHUTDOWN(varnish), 153 | NULL, 154 | NULL, 155 | PHP_MINFO(varnish), 156 | #if ZEND_MODULE_API_NO >= 20010901 157 | PHP_VARNISH_VERSION, 158 | #endif 159 | STANDARD_MODULE_PROPERTIES 160 | }; 161 | /* }}} */ 162 | 163 | #ifdef COMPILE_DL_VARNISH 164 | ZEND_GET_MODULE(varnish) 165 | #endif 166 | 167 | /* {{{ PHP_INI 168 | */ 169 | /* Remove comments and fill if you need to have entries in php.ini 170 | PHP_INI_BEGIN() 171 | STD_PHP_INI_ENTRY("varnish.global_value", "42", PHP_INI_ALL, OnUpdateLong, global_value, zend_varnish_globals, varnish_globals) 172 | STD_PHP_INI_ENTRY("varnish.global_string", "foobar", PHP_INI_ALL, OnUpdateString, global_string, zend_varnish_globals, varnish_globals) 173 | PHP_INI_END() 174 | */ 175 | /* }}} */ 176 | 177 | /* {{{ php_varnish_globals_ctor 178 | */ 179 | /*static void php_varnish_globals_ctor(zend_varnish_globals *varnish_globals) 180 | { 181 | }*/ 182 | /* }}} */ 183 | 184 | /* {{{ php_varnish_globals_dtor 185 | */ 186 | /*static void php_varnish_globals_dtor(zend_varnish_globals *varnish_globals) 187 | { 188 | 189 | }*/ 190 | /* }}} */ 191 | 192 | /* {{{ PHP_MINIT_FUNCTION 193 | */ 194 | PHP_MINIT_FUNCTION(varnish) 195 | { 196 | zend_class_entry ce; 197 | 198 | /* REGISTER_INI_ENTRIES();*/ 199 | /*ZEND_INIT_MODULE_GLOBALS(varnish, php_varnish_globals_ctor, php_varnish_globals_dtor);*/ 200 | 201 | #if PHP_MAJOR_VERSION >= 7 202 | memcpy(&default_varnish_adm_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 203 | default_varnish_adm_handlers.clone_obj = NULL; 204 | default_varnish_adm_handlers.offset = XtOffsetOf(struct ze_varnish_adm_obj, zo); 205 | default_varnish_adm_handlers.free_obj = php_varnish_adm_obj_destroy; 206 | 207 | memcpy(&default_varnish_log_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 208 | default_varnish_log_handlers.clone_obj = NULL; 209 | default_varnish_log_handlers.offset = XtOffsetOf(struct ze_varnish_log_obj, zo); 210 | default_varnish_log_handlers.free_obj = php_varnish_log_obj_destroy; 211 | 212 | memcpy(&default_varnish_stat_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 213 | default_varnish_stat_handlers.clone_obj = NULL; 214 | default_varnish_stat_handlers.offset = XtOffsetOf(struct ze_varnish_stat_obj, zo); 215 | default_varnish_stat_handlers.free_obj = php_varnish_stat_obj_destroy; 216 | #else 217 | memcpy(&default_varnish_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 218 | default_varnish_handlers.clone_obj = NULL; 219 | #endif 220 | 221 | /* Init internal classes */ 222 | INIT_CLASS_ENTRY(ce, "VarnishAdmin", VarnishAdmin_methods); 223 | ce.create_object = php_varnish_adm_obj_init; 224 | VarnishAdmin_ce = zend_register_internal_class(&ce TSRMLS_CC); 225 | 226 | INIT_CLASS_ENTRY(ce, "VarnishStat", VarnishStat_methods); 227 | ce.create_object = php_varnish_stat_obj_init; 228 | VarnishStat_ce = zend_register_internal_class(&ce TSRMLS_CC); 229 | 230 | INIT_CLASS_ENTRY(ce, "VarnishLog", VarnishLog_methods); 231 | ce.create_object = php_varnish_log_obj_init; 232 | VarnishLog_ce = zend_register_internal_class(&ce TSRMLS_CC); 233 | 234 | /* log is not working on windows at the time*/ 235 | #ifndef PHP_WIN32 236 | #if HAVE_VARNISHAPILIB >= 40 237 | #define SLTM(name, flags, shortdesc, longdesc) \ 238 | zend_declare_class_constant_long(VarnishLog_ce, "TAG_"#name, strlen("TAG_"#name), SLT_##name TSRMLS_CC); 239 | #include "tbl/vsl_tags.h" 240 | #else 241 | #define SLTM(foo) \ 242 | zend_declare_class_constant_long(VarnishLog_ce, "TAG_"#foo, strlen("TAG_"#foo), SLT_##foo TSRMLS_CC); 243 | #include "vsl_tags.h" 244 | #endif 245 | #undef SLTM 246 | #endif 247 | /* Init exceptions */ 248 | INIT_CLASS_ENTRY(ce, "VarnishException", NULL); 249 | #if PHP_MAJOR_VERSION >= 7 250 | VarnishException_ce = zend_register_internal_class_ex(&ce, zend_exception_get_default()); 251 | #else 252 | VarnishException_ce = zend_register_internal_class_ex( 253 | &ce, NULL, "exception" TSRMLS_CC 254 | ); 255 | #endif 256 | 257 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_SYNTAX", PHP_VARNISH_STATUS_SYNTAX, CONST_CS | CONST_PERSISTENT); 258 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_UNKNOWN", PHP_VARNISH_STATUS_UNKNOWN, CONST_CS | CONST_PERSISTENT); 259 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_UNIMPL", PHP_VARNISH_STATUS_UNIMPL, CONST_CS | CONST_PERSISTENT); 260 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_TOOFEW", PHP_VARNISH_STATUS_TOOFEW, CONST_CS | CONST_PERSISTENT); 261 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_TOOMANY", PHP_VARNISH_STATUS_TOOMANY, CONST_CS | CONST_PERSISTENT); 262 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_PARAM", PHP_VARNISH_STATUS_PARAM, CONST_CS | CONST_PERSISTENT); 263 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_AUTH", PHP_VARNISH_STATUS_AUTH, CONST_CS | CONST_PERSISTENT); 264 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_OK", PHP_VARNISH_STATUS_OK, CONST_CS | CONST_PERSISTENT); 265 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_CANT", PHP_VARNISH_STATUS_CANT, CONST_CS | CONST_PERSISTENT); 266 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_COMMS", PHP_VARNISH_STATUS_COMMS, CONST_CS | CONST_PERSISTENT); 267 | REGISTER_LONG_CONSTANT("VARNISH_STATUS_CLOSE", PHP_VARNISH_STATUS_CLOSE, CONST_CS | CONST_PERSISTENT); 268 | 269 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_IDENT", "ident", CONST_CS | CONST_PERSISTENT); 270 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_HOST", "host", CONST_CS | CONST_PERSISTENT); 271 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_PORT", "port", CONST_CS | CONST_PERSISTENT); 272 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_TIMEOUT", "timeout", CONST_CS | CONST_PERSISTENT); 273 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_SECRET", "secret", CONST_CS | CONST_PERSISTENT); 274 | REGISTER_STRING_CONSTANT("VARNISH_CONFIG_COMPAT", "compat", CONST_CS | CONST_PERSISTENT); 275 | 276 | REGISTER_LONG_CONSTANT("VARNISH_COMPAT_2", PHP_VARNISH_COMPAT_2, CONST_CS | CONST_PERSISTENT); 277 | REGISTER_LONG_CONSTANT("VARNISH_COMPAT_3", PHP_VARNISH_COMPAT_3, CONST_CS | CONST_PERSISTENT); 278 | 279 | return SUCCESS; 280 | } 281 | /* }}} */ 282 | 283 | /* {{{ PHP_MSHUTDOWN_FUNCTION 284 | */ 285 | PHP_MSHUTDOWN_FUNCTION(varnish) 286 | { 287 | /* uncomment this line if you have INI entries 288 | UNREGISTER_INI_ENTRIES(); 289 | */ 290 | return SUCCESS; 291 | } 292 | /* }}} */ 293 | 294 | /* {{{ PHP_MINFO_FUNCTION 295 | */ 296 | PHP_MINFO_FUNCTION(varnish) 297 | { 298 | php_info_print_table_start(); 299 | php_info_print_table_header(2, "varnish support", "enabled"); 300 | php_info_print_table_row(2, "Extension version", PHP_VARNISH_VERSION); 301 | php_info_print_table_row(2, "Revision", "$Id$"); 302 | #ifdef VMOD_ABI_Version 303 | php_info_print_table_row(2, "Varnish version", VMOD_ABI_Version); 304 | #endif 305 | php_info_print_table_end(); 306 | 307 | /* 308 | DISPLAY_INI_ENTRIES(); 309 | */ 310 | } 311 | /* }}} */ 312 | 313 | /* 314 | * Local variables: 315 | * tab-width: 4 316 | * c-basic-offset: 4 317 | * End: 318 | * vim600: noet sw=4 ts=4 fdm=marker 319 | * vim<600: noet sw=4 ts=4 320 | */ 321 | -------------------------------------------------------------------------------- /package.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | varnish 4 | pecl.php.net 5 | Varnish Cache bindings 6 | Varnish Cache is an open source, state of the art web application accelerator. The extension makes it possible to interact with a running varnish instance through TCP socket or shared memory. 7 | 8 | Anatol Belski 9 | ab 10 | ab@php.net 11 | yes 12 | 13 | 2021-01-17 14 | 15 | 1.2.7 16 | 1.2.7 17 | 18 | 19 | stable 20 | stable 21 | 22 | BSD 23 | 24 | - TODO 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 5.3 91 | 92 | 93 | 1.4.0 94 | 95 | hash 96 | 97 | 98 | varnish 99 | 100 | 101 | 102 | 2021-01-17 103 | 104 | 1.2.6 105 | 1.2.6 106 | 107 | 108 | stable 109 | stable 110 | 111 | BSD 112 | 113 | - Fix missing header 114 | 115 | 116 | 117 | 2021-01-17 118 | 119 | 1.2.5 120 | 1.2.5 121 | 122 | 123 | stable 124 | stable 125 | 126 | BSD 127 | 128 | - Fix PHP 8.0 compatibility (Remi Collet) 129 | 130 | 131 | 132 | 2018-07-01 133 | 134 | 1.2.4 135 | 1.2.4 136 | 137 | 138 | stable 139 | stable 140 | 141 | BSD 142 | 143 | - fix build error -Werror=format-security (Remi Collet) 144 | 145 | 146 | 147 | 2018-03-04 148 | 149 | 1.2.3 150 | 1.2.3 151 | 152 | 153 | stable 154 | stable 155 | 156 | BSD 157 | 158 | - fixed Varnish 5.2 compatibility 159 | 160 | 161 | 162 | 2016-10-23 163 | 164 | 1.2.2 165 | 1.2.2 166 | 167 | 168 | stable 169 | stable 170 | 171 | BSD 172 | 173 | - fixed build with Varnish 5.x, thanks Remi Collet! 174 | 175 | 176 | 177 | 2015-02-14 178 | 179 | 1.2.1 180 | 1.2.1 181 | 182 | 183 | stable 184 | stable 185 | 186 | BSD 187 | 188 | - fixed build with Varnish 4.x (thanks Remi Collet) 189 | 190 | 191 | 192 | 2015-02-13 193 | 194 | 1.2.0 195 | 1.2.0 196 | 197 | 198 | stable 199 | stable 200 | 201 | BSD 202 | 203 | - m4 updated for Varnish 4.x compliance (Remi Collet) 204 | - Varnish 4.x compatibility, but 205 | - VarnishStat and VarnishLog aren't supported when linking to Varnish 4.x anymore 206 | - PHP7 compatibility 207 | 208 | 209 | 210 | 2013-10-01 211 | 212 | 1.1.1 213 | 1.1.1 214 | 215 | 216 | stable 217 | stable 218 | 219 | BSD 220 | 221 | - Fixed bug #65916 (Compilation broken on Mac OS X) 222 | 223 | 224 | 225 | 2013-10-01 226 | 227 | 1.1.0 228 | 1.1.0 229 | 230 | 231 | stable 232 | stable 233 | 234 | BSD 235 | 236 | - fixed object handlers initialization 237 | - improved m4 script (Remi Collet) 238 | - dropped the bundled SHA256 implementation, the hash extension is dependency now instead (Remi Collet) 239 | - RPMs are now available from Remi's repository 240 | - improved the test suite 241 | 242 | 243 | 244 | 2012-08-05 245 | 246 | 1.0.0 247 | 1.0.0 248 | 249 | 250 | stable 251 | stable 252 | 253 | BSD 254 | 255 | - added windows compatibility, though VarnishLog, VarnishStat and auth with ident isn't available there 256 | - fixed socket closing for VarnishAdmin 257 | * added VarnishAdmin::disconnect() 258 | 259 | 260 | 261 | 2012-06-01 262 | 263 | 0.9.3 264 | 1.0.0 265 | 266 | 267 | stable 268 | stable 269 | 270 | BSD 271 | 272 | - Added PHP-5.4 compatibility 273 | - Implemented VarnishAdmin functionality 274 | * VarnishAdmin::getVclList() 275 | * VarnishAdmin::vclUse() 276 | - multiple leak and bug fixes 277 | 278 | 279 | 280 | 2011-10-06 281 | 282 | 0.9.2 283 | 1.0 284 | 285 | 286 | beta 287 | stable 288 | 289 | BSD 290 | 291 | - Added Varnish 2 compatibility 292 | * Configuration option and a setter for VarnishAdmin 293 | * Ban/purge varnish 2/3 compatibility 294 | 295 | 296 | 297 | 298 | 5.3 299 | 300 | 301 | 1.4.0 302 | 303 | linux 304 | 305 | 306 | 307 | 308 | 2011-09-24 309 | 310 | 0.9.1 311 | 1.0 312 | 313 | 314 | beta 315 | stable 316 | 317 | BSD 318 | 319 | - constructor params with wrong type get appropriately converted 320 | - a couple more tests 321 | 322 | 323 | 324 | 325 | 5.3 326 | 327 | 328 | 1.4.0 329 | 330 | linux 331 | 332 | 333 | 334 | 335 | 2011-09-23 336 | 337 | 0.9 338 | 1.0 339 | 340 | 341 | beta 342 | stable 343 | 344 | BSD 345 | 346 | - more exceptions on appropriate places 347 | - minor fixes 348 | - beta documentation is available 349 | 350 | 351 | 352 | 2011-09-02 353 | 354 | 0.8 355 | 1.0 356 | 357 | 358 | alpha 359 | stable 360 | 361 | BSD 362 | 363 | - configuration array is now optional 364 | - ident param, if not given, will be set automatically based on the current hostname 365 | - added setters for the VarnishAdmin configuration 366 | - VarnishAdmin improved with sanity checks for connection and auth 367 | - Ident vs. host/port are mutually exclusive 368 | 369 | 370 | 371 | 2011-08-30 372 | 373 | 0.7 374 | 1.0 375 | 376 | 377 | alpha 378 | stable 379 | 380 | BSD 381 | 382 | - ZTS related fixes by Felipe Pena 383 | - Parameter parsing and other improvements by Hannes Magnusson 384 | - A lot of memory allocation/deallocation fixes 385 | - Added a couple of tests 386 | 387 | 388 | 389 | 2011-08-28 390 | 391 | 0.6 392 | 1.0 393 | 394 | 395 | alpha 396 | stable 397 | 398 | BSD 399 | 400 | - VarnishAdmin 401 | * VarnishAdmin:ban() bases on the vcl ban commando 402 | * VarnishAdmin::banUrl() bases on the vcl ban.url commando 403 | * Arguments are passed to the varnish as given, which is probably a better idea than parsing 404 | them on the php side one more time. The return status value can be used to check if the command 405 | was successful. 406 | * improved VarnishAdmin::isRunning() 407 | - added VarnishLog class 408 | * VarnishLog::getLine() 409 | * VarnishLog::getTagName() 410 | * Varnish log tag list 411 | * Can now read log records from a running varnishd SHM. Not sure, whether more functionality would be sensible, as it requires to run as daemon. 412 | 413 | 414 | 415 | 2011-08-26 416 | 417 | 0.4.1 418 | 1.0 419 | 420 | 421 | alpha 422 | stable 423 | 424 | BSD 425 | 426 | Fix for the package to build 427 | 428 | 429 | 430 | 431 | 0.4 432 | 1.0 433 | 434 | 435 | alpha 436 | stable 437 | 438 | BSD 439 | 440 | - Fixed sereval odd things: 441 | * Missing exceptions 442 | * Varnish param parsing 443 | * Command out reading 444 | - Added clear/get panic methods 445 | 446 | 447 | 448 | 2011-08-23 449 | 450 | 0.3 451 | 1.0 452 | 453 | 454 | alpha 455 | stable 456 | 457 | BSD 458 | 459 | Implemented VarnishAdmin and VarnishStat classes with an minimal set on functionality. 460 | VarnishAdmin: 461 | * connect on varnish administration interface 462 | * authenticate on a varnish instance 463 | * read/write varnish configuration 464 | * ban urls 465 | * start/stop varnish slave 466 | * check varnish slave status 467 | VarnishStat: 468 | * connect to the shared memory 469 | * snapshot the current varnish statistics 470 | There is no documentation for this package yet, please take a look at the tests and sources. 471 | The extension is being currently developed with varnish 3.0 and php 5.3.6, so if you have any issues with older versions, please file a bug. 472 | 473 | 474 | 475 | 476 | 486 | -------------------------------------------------------------------------------- /adm.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "zend_exceptions.h" 39 | #include "php_varnish.h" 40 | 41 | #ifdef PHP_WIN32 42 | #include 43 | #else 44 | #ifdef HAVE_SYS_SOCKET_H 45 | #include 46 | #endif 47 | 48 | #ifdef HAVE_SYS_TYPES_H 49 | #include 50 | #endif 51 | 52 | #ifdef HAVE_NET_INET_H 53 | #include 54 | #endif 55 | #endif 56 | 57 | #include "varnish_lib.h" 58 | #include "exception.h" 59 | 60 | #if PHP_MAJOR_VERSION >= 7 61 | extern zend_object_handlers default_varnish_adm_handlers; 62 | #else 63 | extern zend_object_handlers default_varnish_handlers; 64 | #endif 65 | 66 | #if PHP_MAJOR_VERSION >= 7 67 | void 68 | php_varnish_adm_obj_destroy(zend_object *obj) 69 | {/*{{{*/ 70 | struct ze_varnish_adm_obj *zvao = php_fetch_varnish_adm_obj(obj); 71 | 72 | zend_object_std_dtor(&zvao->zo); 73 | 74 | if (zvao->zvc.host_len > 0) { 75 | efree(zvao->zvc.host); 76 | } 77 | if (zvao->zvc.ident_len > 0) { 78 | efree(zvao->zvc.ident); 79 | } 80 | if (zvao->zvc.secret_len > 0) { 81 | efree(zvao->zvc.secret); 82 | } 83 | if (zvao->zvc.sock >= 0) { 84 | #ifdef PHP_WIN32 85 | closesocket(zvao->zvc.sock); 86 | #else 87 | close(zvao->zvc.sock); 88 | #endif 89 | } 90 | }/*}}}*/ 91 | #else 92 | void 93 | php_varnish_adm_obj_destroy(void *obj TSRMLS_DC) 94 | {/*{{{*/ 95 | struct ze_varnish_adm_obj *zvao = (struct ze_varnish_adm_obj *)obj; 96 | 97 | zend_object_std_dtor(&zvao->zo TSRMLS_CC); 98 | 99 | if (zvao->zvc.host_len > 0) { 100 | efree(zvao->zvc.host); 101 | } 102 | if (zvao->zvc.ident_len > 0) { 103 | efree(zvao->zvc.ident); 104 | } 105 | if (zvao->zvc.secret_len > 0) { 106 | efree(zvao->zvc.secret); 107 | } 108 | if (zvao->zvc.sock >= 0) { 109 | #ifdef PHP_WIN32 110 | closesocket(zvao->zvc.sock); 111 | #else 112 | close(zvao->zvc.sock); 113 | #endif 114 | } 115 | efree(zvao); 116 | }/*}}}*/ 117 | #endif 118 | 119 | #if PHP_MAJOR_VERSION >= 7 120 | zend_object * 121 | php_varnish_adm_obj_init(zend_class_entry *ze) 122 | {/*{{{*/ 123 | struct ze_varnish_adm_obj *zvao; 124 | 125 | zvao = (struct ze_varnish_adm_obj *)ecalloc(1, sizeof(struct ze_varnish_adm_obj)); 126 | 127 | zend_object_std_init(&zvao->zo, ze); 128 | zvao->zo.handlers = &default_varnish_adm_handlers; 129 | 130 | zvao->zvc.host_len = 0; 131 | zvao->zvc.host = NULL; 132 | zvao->zvc.port = -1; 133 | zvao->zvc.secret_len = 0; 134 | zvao->zvc.secret = NULL; 135 | zvao->zvc.timeout = 0; 136 | zvao->zvc.sock = -1; 137 | zvao->zvc.ident_len = 0; 138 | zvao->zvc.ident = NULL; 139 | zvao->zvc.authok = 0; 140 | zvao->status = PHP_VARNISH_STATUS_CLOSE; 141 | zvao->compat = PHP_VARNISH_COMPAT_3; 142 | 143 | return &zvao->zo; 144 | }/*}}}*/ 145 | #else 146 | zend_object_value 147 | php_varnish_adm_obj_init(zend_class_entry *ze TSRMLS_DC) 148 | {/*{{{*/ 149 | zend_object_value ret; 150 | struct ze_varnish_adm_obj *zvao; 151 | #if PHP_VERSION_ID < 50399 152 | zval *tmp; 153 | #endif 154 | 155 | zvao = (struct ze_varnish_adm_obj*)emalloc(sizeof(struct ze_varnish_adm_obj)); 156 | memset(&zvao->zo, 0, sizeof(zend_object)); 157 | 158 | zend_object_std_init(&zvao->zo, ze TSRMLS_CC); 159 | #if PHP_VERSION_ID < 50399 160 | zend_hash_copy(zvao->zo.properties, &ze->default_properties, (copy_ctor_func_t) zval_add_ref, 161 | (void *) &tmp, sizeof(zval *)); 162 | #else 163 | object_properties_init(&zvao->zo, ze); 164 | #endif 165 | 166 | zvao->zvc.host_len = 0; 167 | zvao->zvc.host = NULL; 168 | zvao->zvc.port = -1; 169 | zvao->zvc.secret_len = 0; 170 | zvao->zvc.secret = NULL; 171 | zvao->zvc.timeout = 0; 172 | zvao->zvc.sock = -1; 173 | zvao->zvc.ident_len = 0; 174 | zvao->zvc.ident = NULL; 175 | zvao->zvc.authok = 0; 176 | zvao->status = PHP_VARNISH_STATUS_CLOSE; 177 | zvao->compat = PHP_VARNISH_COMPAT_3; 178 | 179 | ret.handle = zend_objects_store_put(zvao, NULL, 180 | (zend_objects_free_object_storage_t) php_varnish_adm_obj_destroy, 181 | NULL TSRMLS_CC); 182 | 183 | ret.handlers = &default_varnish_handlers; 184 | 185 | return ret; 186 | }/*}}}*/ 187 | #endif 188 | 189 | void 190 | php_varnish_throw_diag_f_exception(void *priv /* fd to output, ignored here */, const char *fmt, ...) 191 | {/*{{{*/ 192 | /* va_list list; 193 | char buff[1024]; 194 | 195 | TSRMLS_FETCH(); 196 | va_start(list, fmt); 197 | 198 | spprintf(&buff, 1024, estrdup(fmt), list); 199 | zend_throw_exception_ex( 200 | VarnishException_ce, 201 | 0 TSRMLS_CC, 202 | estrdup(fmt), 203 | estrdup(buff) 204 | ); 205 | 206 | va_end(list);*/ 207 | }/*}}}*/ 208 | 209 | /* {{{ proto void VarnishAdmin::__construct(array options) 210 | Varnish admin constructor */ 211 | PHP_METHOD(VarnishAdmin, __construct) 212 | { 213 | struct ze_varnish_adm_obj *zvao; 214 | zval *opts = NULL; 215 | 216 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &opts) == FAILURE) { 217 | return; 218 | } 219 | 220 | #if PHP_MAJOR_VERSION >= 7 221 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 222 | #else 223 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 224 | #endif 225 | 226 | if (NULL == opts) { 227 | php_varnish_default_ident(&zvao->zvc.ident, (int*)&zvao->zvc.ident_len); 228 | } else { 229 | /* read config options */ 230 | #if PHP_MAJOR_VERSION >= 7 231 | zval *secret, *addr, *port, *timeout, *ident, *compat; 232 | zend_string *tmp; 233 | 234 | tmp = zend_string_init("host", sizeof("host")-1, 0); 235 | if((addr = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 236 | convert_to_string(addr); 237 | zvao->zvc.host = estrdup(Z_STRVAL_P(addr)); 238 | zvao->zvc.host_len = (int)Z_STRLEN_P(addr); 239 | } 240 | zend_string_release(tmp); 241 | 242 | tmp = zend_string_init("ident", sizeof("ident")-1, 0); 243 | if((ident = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 244 | convert_to_string(ident); 245 | zvao->zvc.ident = estrdup(Z_STRVAL_P(ident)); 246 | zvao->zvc.ident_len = (int)Z_STRLEN_P(ident); 247 | } 248 | zend_string_release(tmp); 249 | 250 | tmp = zend_string_init("port", sizeof("port")-1, 0); 251 | if((port = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 252 | convert_to_long(port); 253 | zvao->zvc.port = (int)Z_LVAL_P(port); 254 | } 255 | zend_string_release(tmp); 256 | 257 | if (zvao->zvc.ident_len > 0 && (zvao->zvc.host_len > 0 || zvao->zvc.port > -1)) { 258 | php_varnish_throw_ident_vs_host_exception(TSRMLS_C); 259 | return; 260 | } 261 | 262 | if (0 == zvao->zvc.ident_len) { 263 | if (zvao->zvc.host_len > 0 && zvao->zvc.port < 0) { 264 | zvao->zvc.port = 2000; 265 | } else if (0 == zvao->zvc.host_len || zvao->zvc.port < 0) { 266 | php_varnish_default_ident(&zvao->zvc.ident, (int*)&zvao->zvc.ident_len); 267 | } 268 | } 269 | 270 | tmp = zend_string_init("timeout", sizeof("timeout")-1, 0); 271 | if((timeout = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 272 | convert_to_long(timeout); 273 | zvao->zvc.timeout = (int)Z_LVAL_P(timeout); 274 | } 275 | zend_string_release(tmp); 276 | 277 | tmp = zend_string_init("compat", sizeof("compat")-1, 0); 278 | if((compat = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 279 | convert_to_long(compat); 280 | zvao->compat = (int)Z_LVAL_P(compat); 281 | } 282 | zend_string_release(tmp); 283 | if (!php_varnish_check_compat(zvao->compat)) { 284 | return; 285 | } 286 | 287 | tmp = zend_string_init("secret", sizeof("secret")-1, 0); 288 | if((secret = zend_hash_find(Z_ARRVAL_P(opts), tmp)) != NULL) { 289 | convert_to_string(secret); 290 | zvao->zvc.secret = estrdup(Z_STRVAL_P(secret)); 291 | zvao->zvc.secret_len = (int)Z_STRLEN_P(secret); 292 | } 293 | zend_string_release(tmp); 294 | #else 295 | zval **secret, **addr, **port, **timeout, **ident, **compat; 296 | 297 | if(zend_hash_find(Z_ARRVAL_P(opts), "host", sizeof("host"), (void**)&addr) != FAILURE) { 298 | convert_to_string(*addr); 299 | zvao->zvc.host = estrdup(Z_STRVAL_PP(addr)); 300 | zvao->zvc.host_len = Z_STRLEN_PP(addr); 301 | } 302 | 303 | if(zend_hash_find(Z_ARRVAL_P(opts), "ident", sizeof("ident"), (void**)&ident) != FAILURE) { 304 | convert_to_string(*ident); 305 | zvao->zvc.ident = estrdup(Z_STRVAL_PP(ident)); 306 | zvao->zvc.ident_len = Z_STRLEN_PP(ident); 307 | } 308 | 309 | if(zend_hash_find(Z_ARRVAL_P(opts), "port", sizeof("port"), (void**)&port) != FAILURE) { 310 | convert_to_long(*port); 311 | zvao->zvc.port = (int)Z_LVAL_PP(port); 312 | } 313 | 314 | if (zvao->zvc.ident_len > 0 && (zvao->zvc.host_len > 0 || zvao->zvc.port > -1)) { 315 | php_varnish_throw_ident_vs_host_exception(TSRMLS_C); 316 | return; 317 | } 318 | 319 | if (0 == zvao->zvc.ident_len) { 320 | if (zvao->zvc.host_len > 0 && zvao->zvc.port < 0) { 321 | zvao->zvc.port = 2000; 322 | } else if (0 == zvao->zvc.host_len || zvao->zvc.port < 0) { 323 | php_varnish_default_ident(&zvao->zvc.ident, (int*)&zvao->zvc.ident_len); 324 | } 325 | } 326 | 327 | if(zend_hash_find(Z_ARRVAL_P(opts), "timeout", sizeof("timeout"), (void**)&timeout) != FAILURE) { 328 | convert_to_long(*timeout); 329 | zvao->zvc.timeout = (int)Z_LVAL_PP(timeout); 330 | } 331 | 332 | if(zend_hash_find(Z_ARRVAL_P(opts), "compat", sizeof("compat"), (void**)&compat) != FAILURE) { 333 | convert_to_long(*compat); 334 | zvao->compat = (int)Z_LVAL_PP(compat); 335 | } 336 | if (!php_varnish_check_compat(zvao->compat TSRMLS_CC)) { 337 | return; 338 | } 339 | 340 | if(zend_hash_find(Z_ARRVAL_P(opts), "secret", sizeof("secret"), (void**)&secret) != FAILURE) { 341 | convert_to_string(*secret); 342 | zvao->zvc.secret = estrdup(Z_STRVAL_PP(secret)); 343 | zvao->zvc.secret_len = Z_STRLEN_PP(secret); 344 | } 345 | #endif 346 | } 347 | } 348 | /* }}} */ 349 | 350 | /* {{{ proto boolean VarnishAdmin::connect() 351 | Connect to a varnish instance */ 352 | PHP_METHOD(VarnishAdmin, connect) 353 | { 354 | struct ze_varnish_adm_obj *zvao; 355 | 356 | if (zend_parse_parameters_none() == FAILURE) { 357 | return; 358 | } 359 | 360 | #if PHP_MAJOR_VERSION >= 7 361 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 362 | #else 363 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 364 | #endif 365 | 366 | /* get the socket */ 367 | if (zvao->zvc.ident_len > 0) { 368 | #ifndef PHP_WIN32 369 | zvao->zvc.sock = php_varnish_sock_ident(zvao->zvc.ident, &zvao->zvc.host, (int*)&zvao->zvc.host_len, &zvao->zvc.port, 370 | zvao->zvc.timeout, &zvao->status TSRMLS_CC); 371 | if (zvao->zvc.sock < 0) { 372 | RETURN_FALSE; 373 | return; 374 | } 375 | #else 376 | php_varnish_throw_win_unimpl_exception("Connection using identity is not supported on windows" TSRMLS_CC); 377 | return; 378 | #endif 379 | } else if (zvao->zvc.host_len > 0) { 380 | zvao->zvc.sock = php_varnish_sock(zvao->zvc.host, zvao->zvc.port, 381 | zvao->zvc.timeout, &zvao->status TSRMLS_CC); 382 | if (zvao->zvc.sock < 0) { 383 | RETURN_FALSE; 384 | return; 385 | } 386 | } 387 | 388 | RETURN_BOOL((zvao->zvc.sock > -1) && (PHP_VARNISH_STATUS_OK == zvao->status)); 389 | } 390 | 391 | /* }}} */ 392 | 393 | /* {{{ proto boolean VarnishAdmin::auth() 394 | Authenticate on a varnish instance */ 395 | PHP_METHOD(VarnishAdmin, auth) 396 | { 397 | struct ze_varnish_adm_obj *zvao; 398 | 399 | if (zend_parse_parameters_none() == FAILURE) { 400 | return; 401 | } 402 | 403 | #if PHP_MAJOR_VERSION >= 7 404 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 405 | #else 406 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 407 | #endif 408 | 409 | zvao->status = PHP_VARNISH_STATUS_AUTH; 410 | 411 | /* authenticate */ 412 | if (zvao->zvc.sock > -1) { 413 | if (zvao->zvc.ident_len > 0) { 414 | #ifndef PHP_WIN32 415 | if(!php_varnish_auth_ident(zvao->zvc.sock, zvao->zvc.ident, 416 | zvao->zvc.timeout, &zvao->status TSRMLS_CC)) { 417 | RETURN_FALSE; 418 | return; 419 | } 420 | #else 421 | php_varnish_throw_win_unimpl_exception("Authentication using identity is not supported on windows" TSRMLS_CC); 422 | return; 423 | #endif 424 | } else if (zvao->zvc.secret_len > 0) { 425 | if(!php_varnish_auth(zvao->zvc.sock, zvao->zvc.secret, 426 | (int)zvao->zvc.secret_len, &zvao->status, zvao->zvc.timeout TSRMLS_CC)) { 427 | RETURN_FALSE; 428 | return; 429 | } 430 | } 431 | } else { 432 | php_varnish_throw_conn_exception(TSRMLS_C); 433 | zvao->zvc.authok = 0; 434 | return; 435 | } 436 | 437 | zvao->zvc.authok = (PHP_VARNISH_STATUS_OK == zvao->status); 438 | 439 | RETURN_BOOL(zvao->zvc.authok); 440 | } 441 | /* }}} */ 442 | 443 | /* {{{ proto int VarnishAdmin::getParams() 444 | Get varnish instance configuration */ 445 | PHP_METHOD(VarnishAdmin, getParams) 446 | { 447 | struct ze_varnish_adm_obj *zvao; 448 | 449 | if (zend_parse_parameters_none() == FAILURE) { 450 | return; 451 | } 452 | 453 | #if PHP_MAJOR_VERSION >= 7 454 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 455 | #else 456 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 457 | #endif 458 | 459 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 460 | return; 461 | } 462 | 463 | array_init(return_value); 464 | php_varnish_get_params(zvao->zvc.sock, &zvao->status, return_value, zvao->zvc.timeout TSRMLS_CC); 465 | } 466 | /* }}} */ 467 | 468 | /* {{{ proto int VarnishAdmin::setParam(string name, mixed value) 469 | Set a varnish instance configuration */ 470 | PHP_METHOD(VarnishAdmin, setParam) 471 | { 472 | zval *val; 473 | char *name, *param; 474 | #if PHP_MAJOR_VERSION >= 7 475 | zval val_str; 476 | size_t name_len; 477 | zend_bool converted = 0; 478 | #else 479 | zval *val_str = NULL; 480 | int name_len; 481 | #endif 482 | int param_len; 483 | struct ze_varnish_adm_obj *zvao; 484 | 485 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name, &name_len, &val) == FAILURE) { 486 | RETURN_LONG(-1); 487 | return; 488 | } 489 | 490 | #if PHP_MAJOR_VERSION >= 7 491 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 492 | #else 493 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 494 | #endif 495 | 496 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 497 | return; 498 | } 499 | 500 | switch (Z_TYPE_P(val)) { 501 | #if PHP_MAJOR_VERSION >= 7 502 | case IS_TRUE: 503 | param = "on"; 504 | param_len = 2; 505 | break; 506 | 507 | case IS_FALSE: 508 | param = "off"; 509 | param_len = 3; 510 | break; 511 | 512 | default: 513 | ZVAL_COPY(&val_str, val); 514 | convert_to_string(&val_str); 515 | 516 | param = Z_STRVAL(val_str); 517 | param_len = Z_STRLEN(val_str); 518 | 519 | converted = 1; 520 | #else 521 | case IS_BOOL: 522 | if (Z_BVAL_P(val)) { 523 | param = "on"; 524 | param_len = 2; 525 | } else { 526 | param = "off"; 527 | param_len = 3; 528 | } 529 | break; 530 | 531 | default: 532 | if (Z_TYPE_P(val) != IS_STRING) { 533 | ALLOC_INIT_ZVAL(val_str); 534 | *val_str = *val; 535 | INIT_PZVAL(val_str); 536 | zval_copy_ctor(val_str); 537 | convert_to_string(val); 538 | } else { 539 | val_str = val; 540 | } 541 | 542 | param = Z_STRVAL_P(val); 543 | param_len = Z_STRLEN_P(val); 544 | #endif 545 | } 546 | 547 | (void)php_varnish_set_param(zvao->zvc.sock, &zvao->status, name, name_len, param, param_len, zvao->zvc.timeout TSRMLS_CC); 548 | 549 | #if PHP_MAJOR_VERSION >= 7 550 | if (converted) { 551 | zval_dtor(&val_str); 552 | } 553 | #else 554 | if (val_str && val != val_str) { 555 | zval_ptr_dtor(&val_str); 556 | } 557 | #endif 558 | 559 | RETURN_LONG(zvao->status); 560 | } 561 | /* }}} */ 562 | 563 | /* {{{ proto int VarnishAdmin::stop() 564 | Stop the varnish instance we are connected to */ 565 | PHP_METHOD(VarnishAdmin, stop) 566 | { 567 | struct ze_varnish_adm_obj *zvao; 568 | 569 | if (zend_parse_parameters_none() == FAILURE) { 570 | return; 571 | } 572 | 573 | #if PHP_MAJOR_VERSION >= 7 574 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 575 | #else 576 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 577 | #endif 578 | 579 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 580 | return; 581 | } 582 | 583 | (void)php_varnish_stop(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout TSRMLS_CC); 584 | 585 | RETURN_LONG(zvao->status); 586 | } 587 | /* }}} */ 588 | 589 | /* {{{ proto int VarnishAdmin::start() 590 | Start the varnish instance we are connected to */ 591 | PHP_METHOD(VarnishAdmin, start) 592 | { 593 | struct ze_varnish_adm_obj *zvao; 594 | 595 | if (zend_parse_parameters_none() == FAILURE) { 596 | return; 597 | } 598 | 599 | #if PHP_MAJOR_VERSION >= 7 600 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 601 | #else 602 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 603 | #endif 604 | 605 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 606 | return; 607 | } 608 | 609 | (void)php_varnish_start(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout TSRMLS_CC); 610 | 611 | RETURN_LONG(zvao->status); 612 | } 613 | /* }}} */ 614 | 615 | /* {{{ proto int VarnishAdmin::banUrl(string regexp) 616 | Ban all the objects where the URL matches the regexp */ 617 | PHP_METHOD(VarnishAdmin, banUrl) 618 | { 619 | char *regex; 620 | #if PHP_MAJOR_VERSION >= 7 621 | size_t regex_len; 622 | #else 623 | int regex_len; 624 | #endif 625 | struct ze_varnish_adm_obj *zvao; 626 | 627 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", ®ex, ®ex_len) == FAILURE) { 628 | RETURN_LONG(-1); 629 | return; 630 | } 631 | 632 | #if PHP_MAJOR_VERSION >= 7 633 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 634 | #else 635 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 636 | #endif 637 | 638 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 639 | return; 640 | } 641 | 642 | php_varnish_ban(zvao->zvc.sock, &zvao->status, regex, regex_len, zvao->zvc.timeout, PHP_VARNISH_BAN_URL_COMMAND, zvao->compat TSRMLS_CC); 643 | 644 | RETURN_LONG(zvao->status); 645 | } 646 | /* }}} */ 647 | 648 | /* {{{ proto int VarnishAdmin::ban(string regexp) 649 | Ban all objects where the conditions match */ 650 | PHP_METHOD(VarnishAdmin, ban) 651 | { 652 | char *regex; 653 | #if PHP_MAJOR_VERSION >= 7 654 | size_t regex_len; 655 | #else 656 | int regex_len; 657 | #endif 658 | struct ze_varnish_adm_obj *zvao; 659 | 660 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", ®ex, ®ex_len) == FAILURE) { 661 | RETURN_LONG(-1); 662 | return; 663 | } 664 | 665 | #if PHP_MAJOR_VERSION >= 7 666 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 667 | #else 668 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 669 | #endif 670 | 671 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 672 | return; 673 | } 674 | 675 | php_varnish_ban(zvao->zvc.sock, &zvao->status, regex, regex_len, zvao->zvc.timeout, PHP_VARNISH_BAN_COMMAND, zvao->compat TSRMLS_CC); 676 | 677 | RETURN_LONG(zvao->status); 678 | } 679 | /* }}} */ 680 | 681 | /*{{{ proto boolean VarnishAdmin::isRunning(void) 682 | Get the status of the current status instance*/ 683 | PHP_METHOD(VarnishAdmin, isRunning) 684 | { 685 | struct ze_varnish_adm_obj *zvao; 686 | int ret; 687 | 688 | if (zend_parse_parameters_none() == FAILURE) { 689 | return; 690 | } 691 | 692 | #if PHP_MAJOR_VERSION >= 7 693 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 694 | #else 695 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 696 | #endif 697 | 698 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 699 | return; 700 | } 701 | 702 | ret = php_varnish_is_running(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout TSRMLS_CC); 703 | 704 | RETURN_BOOL(ret > 0 && PHP_VARNISH_STATUS_OK == zvao->status); 705 | } 706 | /*}}}*/ 707 | 708 | /* {{{ proto string VarnishAdmin::getPanic() 709 | Get the last panic message from the instance we are connected to */ 710 | PHP_METHOD(VarnishAdmin, getPanic) 711 | { 712 | struct ze_varnish_adm_obj *zvao; 713 | char *content; 714 | int content_len; 715 | 716 | if (zend_parse_parameters_none() == FAILURE) { 717 | return; 718 | } 719 | 720 | #if PHP_MAJOR_VERSION >= 7 721 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 722 | #else 723 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 724 | #endif 725 | 726 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 727 | return; 728 | } 729 | 730 | php_varnish_get_panic(zvao->zvc.sock, &zvao->status, &content, &content_len, zvao->zvc.timeout TSRMLS_CC); 731 | 732 | #if PHP_MAJOR_VERSION >= 7 733 | RETURN_STRINGL(content, content_len); 734 | #else 735 | RETURN_STRINGL(content, content_len, 0); 736 | #endif 737 | } 738 | /* }}} */ 739 | 740 | /* {{{ proto integer VarnishAdmin::clearPanic() 741 | Clear the last panic message on the instance we are connected to */ 742 | PHP_METHOD(VarnishAdmin, clearPanic) 743 | { 744 | struct ze_varnish_adm_obj *zvao; 745 | 746 | if (zend_parse_parameters_none() == FAILURE) { 747 | return; 748 | } 749 | 750 | #if PHP_MAJOR_VERSION >= 7 751 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 752 | #else 753 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 754 | #endif 755 | 756 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 757 | return; 758 | } 759 | 760 | php_varnish_clear_panic(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout TSRMLS_CC); 761 | 762 | RETURN_LONG(zvao->status); 763 | } 764 | /* }}} */ 765 | 766 | /* {{{ proto void VarnishAdmin::setHost(string host) 767 | Set the host configuration option */ 768 | PHP_METHOD(VarnishAdmin, setHost) 769 | { 770 | struct ze_varnish_adm_obj *zvao; 771 | char *host; 772 | #if PHP_MAJOR_VERSION >= 7 773 | size_t host_len; 774 | #else 775 | int host_len; 776 | #endif 777 | 778 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &host, &host_len) == FAILURE) { 779 | return; 780 | } 781 | 782 | #if PHP_MAJOR_VERSION >= 7 783 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 784 | #else 785 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 786 | #endif 787 | 788 | if (zvao->zvc.host_len > 0) { 789 | efree(zvao->zvc.host); 790 | } 791 | zvao->zvc.host = estrdup(host); 792 | zvao->zvc.host_len = host_len; 793 | zvao->zvc.authok = 0; 794 | } 795 | /* }}} */ 796 | 797 | /* {{{ proto void VarnishAdmin::setIdent(string host) 798 | Set the ident configuration option */ 799 | PHP_METHOD(VarnishAdmin, setIdent) 800 | { 801 | struct ze_varnish_adm_obj *zvao; 802 | char *ident; 803 | #if PHP_MAJOR_VERSION >= 7 804 | size_t ident_len; 805 | #else 806 | int ident_len; 807 | #endif 808 | 809 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ident, &ident_len) == FAILURE) { 810 | return; 811 | } 812 | 813 | #if PHP_MAJOR_VERSION >= 7 814 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 815 | #else 816 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 817 | #endif 818 | 819 | if (zvao->zvc.ident_len > 0) { 820 | efree(zvao->zvc.ident); 821 | } 822 | zvao->zvc.ident = estrdup(ident); 823 | zvao->zvc.ident_len = ident_len; 824 | zvao->zvc.authok = 0; 825 | } 826 | /* }}} */ 827 | 828 | /* {{{ proto void VarnishAdmin::setSecret(string secret) 829 | Set the secret configuration option */ 830 | PHP_METHOD(VarnishAdmin, setSecret) 831 | { 832 | struct ze_varnish_adm_obj *zvao; 833 | char *secret; 834 | #if PHP_MAJOR_VERSION >= 7 835 | size_t secret_len; 836 | #else 837 | int secret_len; 838 | #endif 839 | 840 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &secret, &secret_len) == FAILURE) { 841 | return; 842 | } 843 | 844 | #if PHP_MAJOR_VERSION >= 7 845 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 846 | #else 847 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 848 | #endif 849 | 850 | if (zvao->zvc.secret_len > 0) { 851 | efree(zvao->zvc.secret); 852 | } 853 | zvao->zvc.secret = estrdup(secret); 854 | zvao->zvc.secret_len = secret_len; 855 | zvao->zvc.authok = 0; 856 | } 857 | /* }}} */ 858 | 859 | /* {{{ proto void VarnishAdmin::setTimeout(int tmo) 860 | Set the timeout configuration option */ 861 | PHP_METHOD(VarnishAdmin, setTimeout) 862 | { 863 | struct ze_varnish_adm_obj *zvao; 864 | zval *tmo; 865 | 866 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &tmo) == FAILURE) { 867 | return; 868 | } 869 | 870 | #if PHP_MAJOR_VERSION >= 7 871 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 872 | #else 873 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 874 | #endif 875 | 876 | convert_to_long(tmo); 877 | zvao->zvc.timeout = (int)Z_LVAL_P(tmo); 878 | } 879 | /* }}} */ 880 | 881 | /* {{{ proto void VarnishAdmin::setPort(int port) 882 | Set the port configuration option */ 883 | PHP_METHOD(VarnishAdmin, setPort) 884 | { 885 | struct ze_varnish_adm_obj *zvao; 886 | zval *port; 887 | 888 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &port) == FAILURE) { 889 | return; 890 | } 891 | 892 | #if PHP_MAJOR_VERSION >= 7 893 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 894 | #else 895 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 896 | #endif 897 | 898 | convert_to_long(port); 899 | zvao->zvc.port = (int)Z_LVAL_P(port); 900 | zvao->zvc.authok = 0; 901 | } 902 | /* }}} */ 903 | 904 | /* {{{ proto void VarnishAdmin::setCompat(int compat) 905 | Set the varnish compatibility */ 906 | PHP_METHOD(VarnishAdmin, setCompat) 907 | { 908 | struct ze_varnish_adm_obj *zvao; 909 | zval *compat; 910 | 911 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &compat) == FAILURE) { 912 | return; 913 | } 914 | 915 | #if PHP_MAJOR_VERSION >= 7 916 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 917 | #else 918 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 919 | #endif 920 | 921 | convert_to_long(compat); 922 | zvao->compat = (int)Z_LVAL_P(compat); 923 | 924 | php_varnish_check_compat(zvao->compat TSRMLS_CC); 925 | } 926 | /* }}} */ 927 | 928 | /*{{{ proto array VarnishAdmin::getVclList(void) 929 | Get VCLs loaded into the varnish instance */ 930 | PHP_METHOD(VarnishAdmin, getVclList) 931 | { 932 | struct ze_varnish_adm_obj *zvao; 933 | 934 | #if PHP_MAJOR_VERSION >= 7 935 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 936 | #else 937 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 938 | #endif 939 | 940 | if (!php_varnish_adm_can_go(zvao TSRMLS_CC)) { 941 | return; 942 | } 943 | 944 | array_init(return_value); 945 | php_varnish_get_vcl_list(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout, return_value TSRMLS_CC); 946 | } 947 | /*}}}*/ 948 | 949 | /*{{{ proto boolean VarnishAdmin::vclUse(string config_name) 950 | Activate the given config */ 951 | PHP_METHOD(VarnishAdmin, vclUse) 952 | { 953 | struct ze_varnish_adm_obj *zvao; 954 | char *conf_name; 955 | #if PHP_MAJOR_VERSION >= 7 956 | size_t conf_name_len; 957 | #else 958 | int conf_name_len; 959 | #endif 960 | int ret; 961 | 962 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &conf_name, &conf_name_len) == FAILURE) { 963 | return; 964 | } 965 | 966 | #if PHP_MAJOR_VERSION >= 7 967 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 968 | #else 969 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 970 | #endif 971 | 972 | /*ret = php_varnish_vcl_use(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout, conf_name, conf_name_len TSRMLS_CC);*/ 973 | ret = php_varnish_vcl_use(zvao->zvc.sock, &zvao->status, zvao->zvc.timeout, conf_name, conf_name_len TSRMLS_CC); 974 | 975 | RETURN_BOOL(ret > 0 && PHP_VARNISH_STATUS_OK == zvao->status); 976 | } 977 | /*}}}*/ 978 | 979 | /*{{{ proto boolean VarnishAdmin::disconnect(void) 980 | Close connection to a varnish instance */ 981 | PHP_METHOD(VarnishAdmin, disconnect) 982 | { 983 | struct ze_varnish_adm_obj *zvao; 984 | 985 | if (zend_parse_parameters_none() == FAILURE) { 986 | return; 987 | } 988 | 989 | #if PHP_MAJOR_VERSION >= 7 990 | zvao = php_fetch_varnish_adm_obj(Z_OBJ_P(getThis())); 991 | #else 992 | zvao = (struct ze_varnish_adm_obj *) zend_object_store_get_object(getThis() TSRMLS_CC); 993 | #endif 994 | 995 | #ifdef PHP_WIN32 996 | RETURN_BOOL(zvao->zvc.sock < 0 ? 0 : (closesocket(zvao->zvc.sock) == 0)); 997 | #else 998 | RETURN_BOOL(zvao->zvc.sock < 0 ? 0 : (close(zvao->zvc.sock) == 0)); 999 | #endif 1000 | } 1001 | /*}}}*/ 1002 | 1003 | /* 1004 | * Local variables: 1005 | * tab-width: 4 1006 | * c-basic-offset: 4 1007 | * End: 1008 | * vim600: noet sw=4 ts=4 fdm=marker 1009 | * vim<600: noet sw=4 ts=4 1010 | */ 1011 | -------------------------------------------------------------------------------- /varnish_lib.c: -------------------------------------------------------------------------------- 1 | /*- 2 | * Copyright (c) 2011-2018 Anatol Belski 3 | * All rights reserved. 4 | * 5 | * Author: Anatol Belski 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 20 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 | * SUCH DAMAGE. 27 | * 28 | * $Id$ 29 | */ 30 | 31 | #ifdef HAVE_CONFIG_H 32 | #include "config.h" 33 | #endif 34 | 35 | #include "php.h" 36 | #include "php_ini.h" 37 | #include "ext/standard/info.h" 38 | #include "zend_exceptions.h" 39 | #include "php_varnish.h" 40 | 41 | #ifdef PHP_WIN32 42 | #undef UNICODE 43 | #include "win32/inet.h" 44 | #include 45 | #include 46 | #include 47 | #include "win32/sockets.h" 48 | 49 | #else 50 | 51 | #if HAVE_SYS_TYPES_H 52 | #include 53 | #endif 54 | #include 55 | #include 56 | #if HAVE_ARPA_INET_H 57 | #include 58 | #endif 59 | #include 60 | 61 | #include 62 | 63 | #include 64 | #endif 65 | 66 | #include "ext/hash/php_hash.h" 67 | #include "ext/hash/php_hash_sha.h" 68 | #include "varnish_lib.h" 69 | #include "exception.h" 70 | 71 | /*{{{ const struct php_varnish_param PHP_VarnishParam[] = { */ 72 | const struct php_varnish_param PHP_VarnishParam[] = { 73 | {PHP_VARNISH_PARAM_ACCEPT_FILTER, PHP_VARNISH_PARAM_BOOL}, 74 | {PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_DECAY, PHP_VARNISH_PARAM_DOUBLE}, 75 | {PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_INCR, PHP_VARNISH_PARAM_DOUBLE}, 76 | {PHP_VARNISH_PARAM_ACCEPTOR_SLEEP_MAX, PHP_VARNISH_PARAM_DOUBLE}, 77 | {PHP_VARNISH_PARAM_AUTO_RESTART, PHP_VARNISH_PARAM_BOOL}, 78 | {PHP_VARNISH_PARAM_BAN_DUPS, PHP_VARNISH_PARAM_BOOL}, 79 | {PHP_VARNISH_PARAM_BAN_LURKER_SLEEP, PHP_VARNISH_PARAM_DOUBLE}, 80 | {PHP_VARNISH_PARAM_BETWEEN_BYTES_TIMEOUT, PHP_VARNISH_PARAM_DOUBLE}, 81 | {PHP_VARNISH_PARAM_CC_COMMAND, PHP_VARNISH_PARAM_STRING}, 82 | {PHP_VARNISH_PARAM_CLI_BUFFER, PHP_VARNISH_PARAM_INT}, 83 | {PHP_VARNISH_PARAM_CLI_TIMEOUT, PHP_VARNISH_PARAM_INT}, 84 | {PHP_VARNISH_PARAM_CLOCK_SKEW, PHP_VARNISH_PARAM_INT}, 85 | {PHP_VARNISH_PARAM_CONNECT_TIMEOUT, PHP_VARNISH_PARAM_DOUBLE}, 86 | {PHP_VARNISH_PARAM_CRITBIT_COOLOFF, PHP_VARNISH_PARAM_DOUBLE}, 87 | {PHP_VARNISH_PARAM_DEFAULT_GRACE, PHP_VARNISH_PARAM_DOUBLE}, 88 | {PHP_VARNISH_PARAM_DEFAULT_KEEP, PHP_VARNISH_PARAM_DOUBLE}, 89 | {PHP_VARNISH_PARAM_DEFAULT_TTL, PHP_VARNISH_PARAM_DOUBLE}, 90 | {PHP_VARNISH_PARAM_DIAG_BITMAP, PHP_VARNISH_PARAM_INT}, 91 | {PHP_VARNISH_PARAM_ESI_SYNTAX, PHP_VARNISH_PARAM_INT}, 92 | {PHP_VARNISH_PARAM_EXPIRY_SLEEP, PHP_VARNISH_PARAM_DOUBLE}, 93 | {PHP_VARNISH_PARAM_FETCH_CHUNKSIZE, PHP_VARNISH_PARAM_INT}, 94 | {PHP_VARNISH_PARAM_FETCH_MAXCHUNKSIZE, PHP_VARNISH_PARAM_INT}, 95 | {PHP_VARNISH_PARAM_FIRST_BYTE_TIMEOUT, PHP_VARNISH_PARAM_DOUBLE}, 96 | {PHP_VARNISH_PARAM_GROUP, PHP_VARNISH_PARAM_STRING}, 97 | {PHP_VARNISH_PARAM_GZIP_LEVEL, PHP_VARNISH_PARAM_INT}, 98 | {PHP_VARNISH_PARAM_GZIP_STACK_BUFFER, PHP_VARNISH_PARAM_INT}, 99 | {PHP_VARNISH_PARAM_GZIP_TMP_SPACE, PHP_VARNISH_PARAM_INT}, 100 | {PHP_VARNISH_PARAM_HTTP_GZIP_SUPPORT, PHP_VARNISH_PARAM_BOOL}, 101 | {PHP_VARNISH_PARAM_HTTP_MAX_HDR, PHP_VARNISH_PARAM_INT}, 102 | {PHP_VARNISH_PARAM_HTTP_RANGE_SUPPORT, PHP_VARNISH_PARAM_BOOL}, 103 | {PHP_VARNISH_PARAM_HTTP_REQ_HDR_LEN, PHP_VARNISH_PARAM_INT}, 104 | {PHP_VARNISH_PARAM_HTTP_REQ_SIZE, PHP_VARNISH_PARAM_INT}, 105 | {PHP_VARNISH_PARAM_HTTP_RESP_HDR_LEN, PHP_VARNISH_PARAM_INT}, 106 | {PHP_VARNISH_PARAM_HTTP_RESP_SIZE, PHP_VARNISH_PARAM_INT}, 107 | {PHP_VARNISH_PARAM_LISTEN_ADDRESS, PHP_VARNISH_PARAM_STRING}, 108 | {PHP_VARNISH_PARAM_LISTEN_DEPTH, PHP_VARNISH_PARAM_INT}, 109 | {PHP_VARNISH_PARAM_LOG_HASHSTRING, PHP_VARNISH_PARAM_BOOL}, 110 | {PHP_VARNISH_PARAM_LOG_LOCAL_ADDRESS, PHP_VARNISH_PARAM_BOOL}, 111 | {PHP_VARNISH_PARAM_LRU_INTERVAL, PHP_VARNISH_PARAM_INT}, 112 | {PHP_VARNISH_PARAM_MAX_ESI_DEPTH, PHP_VARNISH_PARAM_INT}, 113 | {PHP_VARNISH_PARAM_MAX_RESTARTS, PHP_VARNISH_PARAM_INT}, 114 | {PHP_VARNISH_PARAM_PING_INTERVAL, PHP_VARNISH_PARAM_INT}, 115 | {PHP_VARNISH_PARAM_PIPE_TIMEOUT, PHP_VARNISH_PARAM_INT}, 116 | {PHP_VARNISH_PARAM_PREFER_IPV6, PHP_VARNISH_PARAM_BOOL}, 117 | {PHP_VARNISH_PARAM_QUEUE_MAX, PHP_VARNISH_PARAM_INT}, 118 | {PHP_VARNISH_PARAM_RUSH_EXPONENT, PHP_VARNISH_PARAM_INT}, 119 | {PHP_VARNISH_PARAM_SAINTMODE_THRESHOLD, PHP_VARNISH_PARAM_INT}, 120 | {PHP_VARNISH_PARAM_SEND_TIMEOUT, PHP_VARNISH_PARAM_INT}, 121 | {PHP_VARNISH_PARAM_SESS_TIMEOUT, PHP_VARNISH_PARAM_INT}, 122 | {PHP_VARNISH_PARAM_SESS_WORKSPACE, PHP_VARNISH_PARAM_INT}, 123 | {PHP_VARNISH_PARAM_SESSION_LINGER, PHP_VARNISH_PARAM_INT}, 124 | {PHP_VARNISH_PARAM_SESSION_MAX, PHP_VARNISH_PARAM_INT}, 125 | {PHP_VARNISH_PARAM_SHM_RECLEN, PHP_VARNISH_PARAM_INT}, 126 | {PHP_VARNISH_PARAM_SHM_WORKSPACE, PHP_VARNISH_PARAM_INT}, 127 | {PHP_VARNISH_PARAM_SHORTLIVED, PHP_VARNISH_PARAM_DOUBLE}, 128 | {PHP_VARNISH_PARAM_SYSLOG_CLI_TRAFFIC, PHP_VARNISH_PARAM_BOOL}, 129 | {PHP_VARNISH_PARAM_THREAD_POOL_ADD_DELAY, PHP_VARNISH_PARAM_INT}, 130 | {PHP_VARNISH_PARAM_THREAD_POOL_ADD_THRESHOLD, PHP_VARNISH_PARAM_INT}, 131 | {PHP_VARNISH_PARAM_THREAD_POOL_FAIL_DELAY, PHP_VARNISH_PARAM_INT}, 132 | {PHP_VARNISH_PARAM_THREAD_POOL_MAX, PHP_VARNISH_PARAM_INT}, 133 | {PHP_VARNISH_PARAM_THREAD_POOL_MIN, PHP_VARNISH_PARAM_INT}, 134 | {PHP_VARNISH_PARAM_THREAD_POOL_PURGE_DELAY, PHP_VARNISH_PARAM_INT}, 135 | {PHP_VARNISH_PARAM_THREAD_POOL_STACK, PHP_VARNISH_PARAM_INT}, 136 | {PHP_VARNISH_PARAM_THREAD_POOL_TIMEOUT, PHP_VARNISH_PARAM_INT}, 137 | {PHP_VARNISH_PARAM_THREAD_POOL_WORKSPACE, PHP_VARNISH_PARAM_INT}, 138 | {PHP_VARNISH_PARAM_THREAD_POOLS, PHP_VARNISH_PARAM_INT}, 139 | {PHP_VARNISH_PARAM_THREAD_STATS_RATE, PHP_VARNISH_PARAM_INT}, 140 | {PHP_VARNISH_PARAM_USER, PHP_VARNISH_PARAM_STRING}, 141 | {PHP_VARNISH_PARAM_VCC_ERR_UNREF, PHP_VARNISH_PARAM_BOOL}, 142 | {PHP_VARNISH_PARAM_VCL_DIR, PHP_VARNISH_PARAM_STRING}, 143 | {PHP_VARNISH_PARAM_VCL_TRACE, PHP_VARNISH_PARAM_BOOL}, 144 | {PHP_VARNISH_PARAM_VMOD_DIR, PHP_VARNISH_PARAM_STRING}, 145 | {PHP_VARNISH_PARAM_WAITER, PHP_VARNISH_PARAM_STRING} 146 | }; 147 | /*}}}*/ 148 | 149 | static void 150 | php_varnish_parse_add_param(zval *arr, char *line) 151 | {/*{{{*/ 152 | int param_cnt = sizeof(PHP_VarnishParam)/sizeof(struct php_varnish_param); 153 | int i, j, k, ival; 154 | double dval; 155 | char key[96], sval[160], *p; 156 | 157 | p = strchr(line, ' '); 158 | k = (p - line < sizeof key) ? p - line : sizeof(key) - 1; 159 | memcpy(key, line, k); 160 | key[k] = '\0'; 161 | 162 | for (i = 0; i < param_cnt; i++) { 163 | if (!strncmp(key, PHP_VarnishParam[i].param_name, k)) { 164 | break; 165 | } 166 | } 167 | 168 | switch (PHP_VarnishParam[i].param_type) { 169 | case PHP_VARNISH_PARAM_STRING: 170 | j = sscanf(line, "%s %s\n", key, sval); 171 | #if PHP_MAJOR_VERSION >= 7 172 | add_assoc_string(arr, key, sval); 173 | #else 174 | add_assoc_string(arr, key, sval, 1); 175 | #endif 176 | break; 177 | case PHP_VARNISH_PARAM_QUOTED_STRING: 178 | p = strchr(p, '"'); 179 | p++; 180 | for (i = 0; i < 159 && p[i] != '\0'; i++) { 181 | sval[i] = p[i]; 182 | } 183 | sval[i-1] = '\0'; 184 | #if PHP_MAJOR_VERSION >= 7 185 | add_assoc_string(arr, key, sval); 186 | #else 187 | add_assoc_string(arr, key, sval, 1); 188 | #endif 189 | break; 190 | case PHP_VARNISH_PARAM_DOUBLE: 191 | j = sscanf(line, "%s %lf\n", key, &dval); 192 | add_assoc_double(arr, key, dval); 193 | break; 194 | case PHP_VARNISH_PARAM_INT: 195 | j = sscanf(line, "%s %d\n", key, &ival); 196 | add_assoc_long(arr, key, ival); 197 | break; 198 | case PHP_VARNISH_PARAM_BOOL: 199 | j = sscanf(line, "%s %s\n", key, sval); 200 | if (!strncmp("on", sval, 2)) { 201 | add_assoc_bool(arr, key, 1); 202 | } else { 203 | add_assoc_bool(arr, key, 0); 204 | } 205 | break; 206 | } 207 | }/*}}}*/ 208 | 209 | static int 210 | php_varnish_consume_bytes(int sock, char *ptr, int len, int tmo TSRMLS_DC) 211 | {/*{{{*/ 212 | int got_now, i = len, j; 213 | char *p = ptr; 214 | #ifndef PHP_WIN32 215 | struct pollfd pfd; 216 | 217 | pfd.fd = sock; 218 | pfd.events = POLLIN; 219 | 220 | j = poll(&pfd, 1, tmo); 221 | 222 | if (j == 0) { 223 | #else 224 | struct fd_set readfds; 225 | struct timeval ttmo; 226 | 227 | FD_ZERO(&readfds); 228 | FD_SET(sock, &readfds); 229 | 230 | ttmo.tv_sec = 0; 231 | ttmo.tv_usec = tmo*1000; 232 | 233 | j = select(0, &readfds, NULL, NULL, &ttmo); 234 | 235 | if (j <= 0) { 236 | #endif 237 | zend_throw_exception_ex( 238 | VarnishException_ce, 239 | PHP_VARNISH_TMO_EXCEPTION TSRMLS_CC, 240 | "Read operation timed out" 241 | ); 242 | return -1; 243 | } 244 | 245 | while(i > 0) { 246 | got_now = recv(sock, p, i, 0); 247 | if (got_now == -1) { 248 | return -1; 249 | } 250 | i -= got_now; 251 | p += got_now; 252 | } 253 | 254 | return len; 255 | }/*}}}*/ 256 | 257 | static int 258 | php_varnish_send_bytes(int sock, char *ptr, int len) 259 | {/*{{{*/ 260 | int sent, i = len; 261 | char *p = ptr; 262 | 263 | while(i > 0) { 264 | sent = send(sock, p, i, 0); 265 | if (sent == -1) { 266 | return -1; 267 | } 268 | i -= sent; 269 | p += sent; 270 | } 271 | 272 | return len; 273 | }/*}}}*/ 274 | 275 | static int 276 | php_varnish_read_line0(int sock, int *status, int *content_len, int tmo TSRMLS_DC) 277 | {/*{{{*/ 278 | char line0[PHP_VARNISH_LINE0_MAX_LEN]; 279 | int numbytes, j; 280 | 281 | if((numbytes = php_varnish_consume_bytes(sock, line0, PHP_VARNISH_LINE0_MAX_LEN, tmo TSRMLS_CC)) != PHP_VARNISH_LINE0_MAX_LEN) { 282 | zend_throw_exception_ex( 283 | VarnishException_ce, 284 | PHP_VARNISH_HANDSHAKE_EXCEPTION TSRMLS_CC, 285 | "Invalid status line length" 286 | ); 287 | return -1; 288 | } 289 | line0[PHP_VARNISH_LINE0_MAX_LEN-1] = '\0'; 290 | 291 | if (NULL == content_len) { 292 | j = sscanf(line0, "%d ", status); 293 | /* XXX j == 1 */ 294 | } else { 295 | *content_len = 0; 296 | j = sscanf(line0, "%d %d\n", status, content_len); 297 | /* XXX j == 2 */ 298 | } 299 | 300 | return numbytes; 301 | }/*}}}*/ 302 | 303 | static int 304 | php_varnish_invoke_command(int sock, char *command, int command_len, int *status, char **answer, int *answer_len, int tmo TSRMLS_DC) 305 | {/*{{{*/ 306 | int numbytes; 307 | char *cmd, *tmp; 308 | 309 | /* one can use this to just forward the in stream */ 310 | if (command_len) { 311 | cmd = emalloc(command_len+3); 312 | snprintf(cmd, command_len+2, "%s\n", command); 313 | cmd[command_len+2] = '\0'; 314 | 315 | if((numbytes = php_varnish_send_bytes(sock, cmd, command_len+2)) != command_len+2) { 316 | efree(cmd); 317 | php_varnish_throw_comm_exception(TSRMLS_C); 318 | return -1; 319 | } 320 | 321 | efree(cmd); 322 | } 323 | 324 | if((numbytes = php_varnish_read_line0(sock, status, answer_len, tmo TSRMLS_CC)) != PHP_VARNISH_LINE0_MAX_LEN) { 325 | php_varnish_throw_comm_exception(TSRMLS_C); 326 | return 0; 327 | } 328 | 329 | tmp = emalloc(*answer_len+2); 330 | numbytes = php_varnish_consume_bytes(sock, tmp, *answer_len+1, tmo TSRMLS_CC); 331 | tmp[*answer_len+1] = '\0'; 332 | if(numbytes < 0) { 333 | efree(tmp); 334 | php_varnish_throw_comm_exception(TSRMLS_C); 335 | return 0; 336 | } 337 | 338 | *answer = estrdup(tmp); 339 | 340 | efree(tmp); 341 | 342 | return 1; 343 | }/*}}}*/ 344 | 345 | #ifndef PHP_WIN32 346 | int 347 | php_varnish_sock_ident(const char *ident, char **addr, int *addr_len, int *port, int tmo, int *status TSRMLS_DC) 348 | {/*{{{*/ 349 | int sock = -1, j; 350 | #if HAVE_VARNISHAPILIB >= 52 351 | struct vsm *vsd; 352 | #else 353 | struct VSM_data *vsd; 354 | #endif 355 | char *t_arg, *t_start, *p, tmp_addr[41]; 356 | #if HAVE_VARNISHAPILIB >= 52 357 | struct vsm_fantom vt; 358 | #elif HAVE_VARNISHAPILIB >= 40 359 | struct VSM_fantom vt; 360 | #endif 361 | 362 | vsd = VSM_New(); 363 | #if HAVE_VARNISHAPILIB >= 52 364 | if (VSM_Arg(vsd, 'n', ident) >= 0) { 365 | if (VSM_Attach(vsd, -1)) { 366 | #elif HAVE_VARNISHAPILIB >= 40 367 | if (VSM_n_Arg(vsd, ident) > 0) { 368 | if (VSM_Open(vsd)) { 369 | #else 370 | if (VSM_n_Arg(vsd, ident)) { 371 | if (VSM_Open(vsd, 1)) { 372 | #endif 373 | zend_throw_exception_ex( 374 | VarnishException_ce, 375 | PHP_VARNISH_SHM_EXCEPTION TSRMLS_CC, 376 | "%s", 377 | #if HAVE_VARNISHAPILIB >= 40 378 | VSM_Error(vsd) 379 | #else 380 | "Could not open shared memory" 381 | #endif 382 | ); 383 | return sock; 384 | } 385 | 386 | #if HAVE_VARNISHAPILIB >= 52 387 | p = VSM_Dup(vsd, "Arg", "-T"); 388 | if (!p) { 389 | #elif HAVE_VARNISHAPILIB >= 40 390 | if (!VSM_Get(vsd, &vt, "Arg", "-T", "")) { 391 | #else 392 | p = VSM_Find_Chunk(vsd, "Arg", "-T", "", NULL); 393 | if (NULL == p) { 394 | #endif 395 | zend_throw_exception_ex( 396 | VarnishException_ce, 397 | PHP_VARNISH_SHM_EXCEPTION TSRMLS_CC, 398 | "%s", 399 | #if HAVE_VARNISHAPILIB >= 40 400 | VSM_Error(vsd) 401 | #else 402 | "No address and port found in the shared memory" 403 | #endif 404 | ); 405 | #if HAVE_VARNISHAPILIB >= 52 406 | VSM_Destroy(&vsd); 407 | #else 408 | VSM_Delete(vsd); 409 | #endif 410 | return sock; 411 | } 412 | #if HAVE_VARNISHAPILIB >= 52 413 | t_start = t_arg = estrdup(p); 414 | #elif HAVE_VARNISHAPILIB >= 40 415 | t_start = t_arg = estrdup(vt.b); 416 | #else 417 | t_start = t_arg = estrdup(p); 418 | #endif 419 | 420 | 421 | } else { 422 | zend_throw_exception_ex( 423 | VarnishException_ce, 424 | PHP_VARNISH_CONN_EXCEPTION TSRMLS_CC, 425 | "Invalid identity param" 426 | ); 427 | return sock; 428 | } 429 | 430 | #if HAVE_VARNISHAPILIB >= 52 431 | VSM_Destroy(&vsd); 432 | #elif HAVE_VARNISHAPILIB >= 40 433 | VSM_Delete(vsd); 434 | #endif 435 | 436 | while(*t_arg) { 437 | p = strchr(t_arg, '\n'); 438 | if (NULL == p) { 439 | zend_throw_exception_ex( 440 | VarnishException_ce, 441 | PHP_VARNISH_SHM_EXCEPTION TSRMLS_CC, 442 | "Invalid address or port data in the shared memory" 443 | ); 444 | return sock; 445 | } 446 | *p = '\0'; 447 | j = sscanf(t_arg, "%s %d", tmp_addr, port); 448 | /* XXX j == 2 */ 449 | sock = php_varnish_sock(tmp_addr, *port, tmo, status TSRMLS_CC); 450 | if (sock > -1) { 451 | *addr = estrdup(tmp_addr); 452 | *addr_len = strlen(*addr); 453 | break; 454 | } 455 | t_arg = ++p; 456 | } 457 | 458 | efree(t_start); 459 | 460 | return sock; 461 | }/*}}}*/ 462 | #endif 463 | 464 | int 465 | php_varnish_sock(const char *addr, int port, int tmo, int *status TSRMLS_DC) 466 | {/*{{{*/ 467 | int sock = -1, rc; 468 | struct in6_addr serveraddr; 469 | struct addrinfo hints, *res = NULL; 470 | char port_buf[8]; 471 | 472 | do { 473 | memset(&hints, 0, sizeof hints); 474 | hints.ai_flags = AI_NUMERICSERV; 475 | hints.ai_family = AF_UNSPEC; 476 | hints.ai_socktype = SOCK_STREAM; 477 | 478 | rc = inet_pton(AF_INET, addr, &serveraddr); 479 | if (1 == rc) { 480 | hints.ai_family = AF_INET; 481 | hints.ai_flags |= AI_NUMERICHOST; 482 | } else { 483 | rc = inet_pton(AF_INET6, addr, &serveraddr); 484 | if (1 == rc) { 485 | hints.ai_family = AF_INET6; 486 | hints.ai_flags |= AI_NUMERICHOST; 487 | } else { 488 | /* XXX get host by name ??? */ 489 | } 490 | } 491 | 492 | snprintf(port_buf, 7, "%d", port); 493 | rc = getaddrinfo(addr, port_buf, &hints, &res); 494 | if (0 != rc) { 495 | #ifndef PHP_WIN32 496 | if (rc == EAI_SYSTEM) { 497 | zend_throw_exception_ex( 498 | VarnishException_ce, 499 | PHP_VARNISH_SOCK_EXCEPTION TSRMLS_CC, 500 | "Could not translate address '%s'", 501 | addr 502 | ); 503 | } else { 504 | #endif 505 | zend_throw_exception_ex( 506 | VarnishException_ce, 507 | PHP_VARNISH_SOCK_EXCEPTION TSRMLS_CC, 508 | "Host '%s' not found. %s", 509 | addr, 510 | estrdup(gai_strerror(rc)) 511 | ); 512 | #ifndef PHP_WIN32 513 | } 514 | #endif 515 | return sock; 516 | } 517 | 518 | if((sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) { 519 | zend_throw_exception_ex( 520 | VarnishException_ce, 521 | PHP_VARNISH_SOCK_EXCEPTION TSRMLS_CC, 522 | "Unable to create socket" 523 | ); 524 | *status = PHP_VARNISH_STATUS_COMMS; 525 | return sock; 526 | } 527 | 528 | if(connect(sock, res->ai_addr, res->ai_addrlen) == -1) { 529 | zend_throw_exception_ex( 530 | VarnishException_ce, 531 | PHP_VARNISH_CONN_EXCEPTION TSRMLS_CC, 532 | "Unable to connect to '%s' on port '%d'", 533 | addr, port 534 | ); 535 | *status = PHP_VARNISH_STATUS_COMMS; 536 | return -1; 537 | } 538 | 539 | } while (0); 540 | 541 | *status = PHP_VARNISH_STATUS_OK; 542 | 543 | return sock; 544 | }/*}}}*/ 545 | 546 | #ifndef PHP_WIN32 547 | int 548 | php_varnish_auth_ident(int sock, const char *ident, int tmo, int *status TSRMLS_DC) 549 | {/*{{{*/ 550 | #if HAVE_VARNISHAPILIB >= 52 551 | struct vsm *vsd; 552 | #else 553 | struct VSM_data *vsd; 554 | #endif 555 | char *s_arg, *answer = NULL; 556 | int fd; 557 | char buf[CLI_AUTH_RESPONSE_LEN + 1]; 558 | #if HAVE_VARNISHAPILIB >= 52 559 | struct vsm_fantom vt; 560 | char *p; 561 | #elif HAVE_VARNISHAPILIB >= 40 562 | struct VSM_fantom vt; 563 | #else 564 | char *p; 565 | #endif 566 | 567 | (void)VCLI_ReadResult(sock, status, &answer, tmo); 568 | if (PHP_VARNISH_STATUS_AUTH == *status) { 569 | vsd = VSM_New(); 570 | #if HAVE_VARNISHAPILIB >= 52 571 | if (VSM_Arg(vsd, 'n', ident) >= 0) { 572 | #else 573 | if (VSM_n_Arg(vsd, ident)) { 574 | #endif 575 | #if HAVE_VARNISHAPILIB >= 52 576 | if (VSM_Attach(vsd, -1)) { 577 | #elif HAVE_VARNISHAPILIB >= 40 578 | if (VSM_Open(vsd)) { 579 | #else 580 | if (VSM_Open(vsd, 1)) { 581 | #endif 582 | zend_throw_exception_ex( 583 | VarnishException_ce, 584 | PHP_VARNISH_SHM_EXCEPTION TSRMLS_CC, 585 | "Could not open shared memory" 586 | ); 587 | return sock; 588 | } 589 | 590 | #if HAVE_VARNISHAPILIB >= 52 591 | p = VSM_Dup(vsd, "Arg", "-S"); 592 | if (p != NULL) { 593 | s_arg = estrdup(p); 594 | #elif HAVE_VARNISHAPILIB >= 40 595 | if (VSM_Get(vsd, &vt, "Arg", "-S", "")) { 596 | s_arg = estrdup(vt.b); 597 | #else 598 | p = VSM_Find_Chunk(vsd, "Arg", "-S", "", NULL); 599 | if (p != NULL) { 600 | s_arg = estrdup(p); 601 | #endif 602 | fd = open(s_arg, O_RDONLY); 603 | if (fd < 0) { 604 | zend_throw_exception_ex( 605 | VarnishException_ce, 606 | PHP_VARNISH_AUTH_EXCEPTION TSRMLS_CC, 607 | "Unable to open secret file at '%s'", 608 | s_arg 609 | ); 610 | return 0; 611 | } 612 | efree(s_arg); 613 | #if HAVE_VARNISHAPILIB >= 52 614 | } else { 615 | VSM_Destroy(&vsd); 616 | return 0; 617 | #elif HAVE_VARNISHAPILIB >= 40 618 | } else { 619 | VSM_Delete(vsd); 620 | return 0; 621 | #endif 622 | } 623 | VCLI_AuthResponse(fd, answer, buf); 624 | close(fd); 625 | free(answer); 626 | 627 | if(-1 == php_varnish_send_bytes(sock, "auth ", strlen("auth "))) { 628 | php_varnish_throw_comm_exception(TSRMLS_C); 629 | } 630 | if(-1 == php_varnish_send_bytes(sock, buf, CLI_AUTH_RESPONSE_LEN)) { 631 | php_varnish_throw_comm_exception(TSRMLS_C); 632 | } 633 | if(-1 == php_varnish_send_bytes(sock, "\n", strlen("\n"))) { 634 | php_varnish_throw_comm_exception(TSRMLS_C); 635 | } 636 | 637 | (void)VCLI_ReadResult(sock, status, &answer, tmo); 638 | free(answer); 639 | } 640 | } 641 | 642 | return 1; 643 | }/*}}}*/ 644 | #endif 645 | 646 | int 647 | php_varnish_auth(int sock, char *secret, int secret_len, int *status, int tmo TSRMLS_DC) 648 | {/*{{{*/ 649 | char challenge[PHP_VARNISH_CHALLENGE_LEN+1], buf[64], *content; 650 | unsigned char binbuf[32]; 651 | int numbytes, content_len; 652 | PHP_SHA256_CTX ctx256; 653 | 654 | if((numbytes = php_varnish_read_line0(sock, status, &content_len, tmo TSRMLS_CC)) != PHP_VARNISH_LINE0_MAX_LEN) { 655 | zend_throw_exception_ex( 656 | VarnishException_ce, 657 | PHP_VARNISH_HANDSHAKE_EXCEPTION TSRMLS_CC, 658 | "Initial handshake failed" 659 | ); 660 | return 0; 661 | } 662 | 663 | if (PHP_VARNISH_STATUS_AUTH == *status) { 664 | content = emalloc(content_len+2); 665 | content[content_len+1] = '\0'; 666 | numbytes = php_varnish_consume_bytes(sock, content, content_len, tmo TSRMLS_CC); 667 | if(numbytes < 0) { 668 | php_varnish_throw_comm_exception(TSRMLS_C); 669 | return 0; 670 | } 671 | 672 | memcpy(challenge, content, PHP_VARNISH_CHALLENGE_LEN); 673 | challenge[PHP_VARNISH_CHALLENGE_LEN] = '\0'; 674 | efree(content); 675 | 676 | PHP_SHA256Init(&ctx256); 677 | PHP_SHA256Update(&ctx256, (unsigned char*)challenge, PHP_VARNISH_CHALLENGE_LEN); 678 | PHP_SHA256Update(&ctx256, (unsigned char*)"\n", 1); 679 | PHP_SHA256Update(&ctx256, (unsigned char*)secret, secret_len); 680 | PHP_SHA256Update(&ctx256, (unsigned char*)"\n", 1); 681 | PHP_SHA256Update(&ctx256, (unsigned char*)challenge, PHP_VARNISH_CHALLENGE_LEN); 682 | PHP_SHA256Update(&ctx256, (unsigned char*)"\n", 1); 683 | PHP_SHA256Final(binbuf, &ctx256); 684 | php_hash_bin2hex(buf, binbuf, 32); 685 | 686 | if(-1 == php_varnish_send_bytes(sock, "auth ", strlen("auth "))) { 687 | php_varnish_throw_comm_exception(TSRMLS_C); 688 | } 689 | if(-1 == php_varnish_send_bytes(sock, buf, 64)) { 690 | php_varnish_throw_comm_exception(TSRMLS_C); 691 | } 692 | if(-1 == php_varnish_send_bytes(sock, "\n", strlen("\n"))) { 693 | php_varnish_throw_comm_exception(TSRMLS_C); 694 | } 695 | 696 | /* forward to the end of the varnish out */ 697 | php_varnish_invoke_command(sock, NULL, 0, status, &content, &content_len, tmo TSRMLS_CC); 698 | efree(content); 699 | } 700 | 701 | return 1; 702 | }/*}}}*/ 703 | 704 | int 705 | php_varnish_get_params(int sock, int *status, zval *storage, int tmo TSRMLS_DC) 706 | {/*{{{*/ 707 | int i = 0, content_len, len, ret; 708 | char *content, *p0, *p1, buf[256]; 709 | 710 | ret = php_varnish_invoke_command(sock, "param.show", 10, status, &content, &content_len, tmo TSRMLS_CC); 711 | 712 | p0 = p1 = content; 713 | while(i < content_len) { 714 | while(*p1 != '\0' && *p1 != '\n' && *p1 != '\r') { 715 | p1++; 716 | } 717 | 718 | len = p1 - p0; 719 | if (0 != len) { 720 | memcpy(buf, p0, (len > 255 ? 255 : len)); 721 | buf[len] = '\0'; 722 | php_varnish_parse_add_param(storage, buf); 723 | } 724 | p0 = ++p1; 725 | i += len + 1; 726 | } 727 | 728 | efree(content); 729 | 730 | return 1; 731 | }/*}}}*/ 732 | 733 | int 734 | php_varnish_set_param(int sock, int *status, char *key, int key_len, char *param, int param_len, int tmo TSRMLS_DC) 735 | {/*{{{*/ 736 | char *content, buf[256]; 737 | int content_len, ret, cmd_len = key_len + param_len + 11; 738 | 739 | snprintf(buf, 255, "param.set %s %s", key, param); 740 | buf[(cmd_len > 255 ? 255 : cmd_len)] = '\0'; 741 | 742 | ret = php_varnish_invoke_command(sock, buf, cmd_len, status, &content, &content_len, tmo TSRMLS_CC); 743 | 744 | efree(content); 745 | 746 | return ret; 747 | }/*}}}*/ 748 | 749 | int 750 | php_varnish_stop(int sock, int *status, int tmo TSRMLS_DC) 751 | {/*{{{*/ 752 | char *content; 753 | int content_len, ret; 754 | 755 | ret = php_varnish_invoke_command(sock, "stop", 4, status, &content, &content_len, tmo TSRMLS_CC); 756 | 757 | efree(content); 758 | 759 | return ret; 760 | }/*}}}*/ 761 | 762 | 763 | int 764 | php_varnish_start(int sock, int *status, int tmo TSRMLS_DC) 765 | {/*{{{*/ 766 | char *content; 767 | int content_len, ret; 768 | 769 | ret = php_varnish_invoke_command(sock, "start", 5, status, &content, &content_len, tmo TSRMLS_CC); 770 | 771 | efree(content); 772 | 773 | return ret; 774 | }/*}}}*/ 775 | 776 | int 777 | php_varnish_ban(int sock, int *status, char *reg, int reg_len, int tmo, int type, int compat TSRMLS_DC) 778 | {/*{{{*/ 779 | char *content, buf[2048]; 780 | int content_len, int_len = 0, ban_flag; 781 | 782 | /* for now there is only varnish 2 vs 3 issue, so kiss */ 783 | ban_flag = (PHP_VARNISH_COMPAT_2 == compat); 784 | 785 | switch (type) { 786 | case PHP_VARNISH_BAN_COMMAND: 787 | int_len = ban_flag ? 6 : 4; 788 | snprintf( 789 | buf, 790 | 2047-int_len, 791 | "%s %s", 792 | (ban_flag ? "purge" : "ban"), 793 | reg 794 | ); 795 | break; 796 | 797 | case PHP_VARNISH_BAN_URL_COMMAND: 798 | int_len = ban_flag ? 10 : 8; 799 | snprintf( 800 | buf, 801 | 2047-int_len, 802 | "%s %s", 803 | (ban_flag ? "purge.url" : "ban.url"), 804 | reg 805 | ); 806 | break; 807 | 808 | default: 809 | zend_throw_exception_ex( 810 | VarnishException_ce, 811 | PHP_VARNISH_UNKNOWN_EXCEPTION TSRMLS_CC, 812 | "Unknown ban command type" 813 | ); 814 | break; 815 | } 816 | buf[reg_len+int_len] = '\0'; 817 | 818 | return php_varnish_invoke_command(sock, buf, reg_len+int_len, status, &content, &content_len, tmo TSRMLS_CC); 819 | }/*}}}*/ 820 | 821 | #ifndef PHP_WIN32 822 | #if HAVE_VARNISHAPILIB < 40 823 | static int 824 | php_varnish_snap_stats_cb(void *priv, const struct VSC_point const *pt) 825 | {/*{{{*/ 826 | uint64_t val; 827 | int f0, f1; 828 | zval *storage, *current; 829 | char buf0[128]; 830 | #if HAVE_VARNISHAPILIB >= 40 831 | const char *type = pt->section->type; 832 | const char *ident = pt->section->ident; 833 | const char *name = pt->desc->name; 834 | #else 835 | char *type = pt->class; 836 | char *ident = pt->ident; 837 | char *name = pt->name; 838 | #endif 839 | 840 | storage = priv; 841 | 842 | val = *(const volatile uint64_t*)pt->ptr; 843 | 844 | f0 = strcmp(type, ""); 845 | f1 = strcmp(ident, ""); 846 | snprintf(buf0, 128, "%s%s%s%s%s", 847 | (f0 ? type : ""), 848 | (f0 ? "." : ""), 849 | (f1 ? ident : ""), 850 | (f1 ? "." : ""), 851 | name); 852 | 853 | add_assoc_long(storage, buf0, val); 854 | 855 | return 0; 856 | }/*}}}*/ 857 | #endif 858 | 859 | #if HAVE_VARNISHAPILIB >= 40 860 | int 861 | php_varnish_snap_stats(zval *storage, const char *ident TSRMLS_DC) 862 | {/*{{{*/ 863 | return 0; 864 | }/*}}}*/ 865 | #else 866 | int 867 | php_varnish_snap_stats(zval *storage, const char *ident TSRMLS_DC) 868 | {/*{{{*/ 869 | #if HAVE_VARNISHAPILIB >= 52 870 | struct vsm *vsd; 871 | #else 872 | struct VSM_data *vd; 873 | #endif 874 | const struct VSC_C_main *vcm; 875 | 876 | vd = VSM_New(); 877 | VSC_Setup(vd); 878 | 879 | VSC_Arg(vd, 'n', ident); 880 | 881 | if (VSC_Open(vd, 1)) { /* 0 on success */ 882 | zend_throw_exception_ex( 883 | VarnishException_ce, 884 | PHP_VARNISH_SHM_EXCEPTION TSRMLS_CC, 885 | "Could not open shared memory" 886 | ); 887 | return 0; 888 | } 889 | 890 | vcm = VSC_Main(vd); 891 | 892 | return !VSC_Iter(vd, php_varnish_snap_stats_cb, storage); 893 | }/*}}}*/ 894 | #endif 895 | 896 | #if HAVE_VARNISHAPILIB >= 52 897 | int 898 | php_varnish_get_log(const struct vsm *vd, zval *line TSRMLS_DC) 899 | {/*{{{*/ 900 | return 0; 901 | }/*}}}*/ 902 | #elif HAVE_VARNISHAPILIB >= 40 903 | int 904 | php_varnish_get_log(const struct VSM_data *vd, zval *line TSRMLS_DC) 905 | {/*{{{*/ 906 | return 0; 907 | }/*}}}*/ 908 | #else 909 | int 910 | php_varnish_get_log(const struct VSM_data *vd, zval *line TSRMLS_DC) 911 | {/*{{{*/ 912 | uint32_t *p; 913 | int i; 914 | 915 | i = VSL_NextLog(vd, &p, NULL); 916 | 917 | if (i < 0) { 918 | zend_throw_exception_ex( 919 | VarnishException_ce, 920 | PHP_VARNISH_CANT_EXCEPTION TSRMLS_CC, 921 | "Can't get next log line" 922 | ); 923 | return 0; 924 | } 925 | 926 | if (i > 0) { 927 | #if PHP_MAJOR_VERSION >= 7 928 | add_assoc_stringl(line, "data", VSL_DATA(p), VSL_LEN(p)); 929 | #else 930 | add_assoc_stringl(line, "data", VSL_DATA(p), VSL_LEN(p), 1); 931 | #endif 932 | add_assoc_long(line, "tag", VSL_TAG(p)); 933 | add_assoc_long(line, "id", VSL_ID(p)); 934 | } 935 | 936 | return 1; 937 | 938 | }/*}}}*/ 939 | #endif 940 | #endif 941 | 942 | int 943 | php_varnish_is_running(int sock, int *status, int tmo TSRMLS_DC) 944 | {/*{{{*/ 945 | char *content, *msg, *p; 946 | int content_len, ret = 0, msg_len; 947 | 948 | /* must parse the content message here, as the status would be always 200 in varnish 3.0 at least */ 949 | msg = "Child in state running"; 950 | msg_len = strlen(msg); 951 | 952 | ret = php_varnish_invoke_command(sock, "status", 6, status, &content, &content_len, tmo TSRMLS_CC); 953 | 954 | p = content; 955 | while (!isalpha(*p)) { 956 | p++; 957 | } 958 | 959 | if (ret > 0) { 960 | ret = !memcmp(msg, p, msg_len); 961 | } 962 | 963 | efree(content); 964 | 965 | return ret; 966 | }/*}}}*/ 967 | 968 | int 969 | php_varnish_get_panic(int sock, int *status, char **content, int *content_len, int tmo TSRMLS_DC) 970 | {/*{{{*/ 971 | int ret; 972 | 973 | ret = php_varnish_invoke_command(sock, "panic.show", 10, status, content, content_len, tmo TSRMLS_CC); 974 | 975 | return ret; 976 | }/*}}}*/ 977 | 978 | int 979 | php_varnish_clear_panic(int sock, int *status, int tmo TSRMLS_DC) 980 | {/*{{{*/ 981 | char *content; 982 | int content_len; 983 | 984 | return php_varnish_invoke_command(sock, "panic.clear", 11, status, &content, &content_len, tmo TSRMLS_CC); 985 | } /*}}}*/ 986 | 987 | #ifndef PHP_WIN32 988 | void 989 | php_varnish_log_get_tag_name(int index, char **ret, int *ret_len TSRMLS_DC) 990 | {/*{{{*/ 991 | int max = sizeof(VSL_tags)/sizeof(char*); 992 | 993 | *ret = ""; 994 | *ret_len = 0; 995 | 996 | if (index >= 0 && index < max) { 997 | const char *tmp; 998 | tmp = VSL_tags[index]; 999 | if (tmp) { 1000 | *ret = estrdup(tmp); 1001 | *ret_len = strlen(*ret); 1002 | } 1003 | } 1004 | }/*}}}*/ 1005 | #endif 1006 | 1007 | void 1008 | php_varnish_default_ident(char **ident, int *ident_len) 1009 | {/*{{{*/ 1010 | char buf[64]; 1011 | 1012 | gethostname(buf, 63); 1013 | 1014 | *ident = emalloc(128); 1015 | snprintf(*ident, 127, "/var/lib/varnish/%s", buf); 1016 | 1017 | *ident_len = strlen(*ident); 1018 | }/*}}}*/ 1019 | 1020 | int 1021 | php_varnish_adm_can_go(struct ze_varnish_adm_obj *zvao TSRMLS_DC) 1022 | {/*{{{*/ 1023 | if (zvao->zvc.sock < 0) { 1024 | php_varnish_throw_conn_exception(TSRMLS_C); 1025 | return 0; 1026 | } 1027 | 1028 | if (!zvao->zvc.authok) { 1029 | php_varnish_throw_auth_exception(TSRMLS_C); 1030 | return 0; 1031 | } 1032 | 1033 | return 1; 1034 | }/*}}}*/ 1035 | 1036 | int 1037 | php_varnish_check_compat(int compat TSRMLS_DC) 1038 | {/*{{{*/ 1039 | if (PHP_VARNISH_COMPAT_2 != compat && PHP_VARNISH_COMPAT_3 != compat) { 1040 | zend_throw_exception_ex( 1041 | VarnishException_ce, 1042 | PHP_VARNISH_COMPAT_EXCEPTION TSRMLS_CC, 1043 | "Unsupported compatibility option '%d'", 1044 | compat 1045 | ); 1046 | return 0; 1047 | } 1048 | 1049 | return 1; 1050 | }/*}}}*/ 1051 | 1052 | int 1053 | php_varnish_get_vcl_list(int sock, int *status, int tmo, zval *retval TSRMLS_DC) 1054 | {/*{{{*/ 1055 | int i = 0, content_len, len, ret; 1056 | char *content, *p0, *p1; 1057 | 1058 | ret = php_varnish_invoke_command(sock, "vcl.list", 8, status, &content, &content_len, tmo TSRMLS_CC); 1059 | 1060 | if (ret > 0) { 1061 | p0 = p1 = content; 1062 | while (i < content_len) { 1063 | char st[32], name[208], buf[256]; 1064 | /*assume locks as string is 16 digits long*/ 1065 | long locks; 1066 | 1067 | while (*p1 != '\0' && *p1 != '\n' && *p1 != '\r') { 1068 | p1++; 1069 | } 1070 | 1071 | len = p1 - p0; 1072 | len = len > 255 ? 255 : len; 1073 | memcpy(buf, p0, len); 1074 | buf[len] = '\0'; 1075 | 1076 | if (3 == sscanf(buf, "%32s %16ld %208s", st, &locks, name)) { 1077 | #if PHP_MAJOR_VERSION >= 7 1078 | zval tmp; 1079 | array_init(&tmp); 1080 | add_assoc_stringl(&tmp, "status", st, strlen(st)); 1081 | add_assoc_stringl(&tmp, "name", name, strlen(name)); 1082 | add_assoc_long(&tmp, "locks", locks); 1083 | 1084 | add_next_index_zval(retval, &tmp); 1085 | #else 1086 | zval *tmp; 1087 | MAKE_STD_ZVAL(tmp); 1088 | array_init(tmp); 1089 | add_assoc_stringl(tmp, "status", st, strlen(st), 1); 1090 | add_assoc_stringl(tmp, "name", name, strlen(name), 1); 1091 | add_assoc_long(tmp, "locks", locks); 1092 | 1093 | add_next_index_zval(retval, tmp); 1094 | #endif 1095 | } 1096 | 1097 | p0 = ++p1; 1098 | i += len + 1; 1099 | } 1100 | efree(content); 1101 | } 1102 | 1103 | return ret; 1104 | }/*}}}*/ 1105 | 1106 | int 1107 | php_varnish_vcl_use(int sock, int *status, int tmo, char *vcl_name, int vcl_name_len TSRMLS_DC) 1108 | {/*{{{*/ 1109 | char *content, buf[256]; 1110 | int content_len, ret, cmd_len = vcl_name_len + 8; 1111 | 1112 | snprintf(buf, 255, "vcl.use %s", vcl_name); 1113 | buf[(cmd_len > 255 ? 255 : cmd_len)] = '\0'; 1114 | 1115 | ret = php_varnish_invoke_command(sock, buf, cmd_len, status, &content, &content_len, tmo TSRMLS_CC); 1116 | 1117 | if (ret > 0) { 1118 | efree(content); 1119 | } 1120 | 1121 | return ret; 1122 | }/*}}}*/ 1123 | 1124 | /* 1125 | * Local variables: 1126 | * tab-width: 4 1127 | * c-basic-offset: 4 1128 | * End: 1129 | * vim600: noet sw=4 ts=4 fdm=marker 1130 | * vim<600: noet sw=4 ts=4 1131 | */ 1132 | --------------------------------------------------------------------------------