PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/shmop - shmop.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 69 100 69.0 %
Date: 2014-09-27 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Slava Poliakov <hackie@prohost.org>                         |
      16             :    |          Ilia Alshanetsky <ilia@prohost.org>                         |
      17             :    +----------------------------------------------------------------------+
      18             :  */
      19             : /* $Id$ */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include "config.h"
      23             : #endif
      24             : 
      25             : #include "php.h"
      26             : #include "php_ini.h"
      27             : #include "php_shmop.h"
      28             : # ifndef PHP_WIN32
      29             : # include <sys/ipc.h>
      30             : # include <sys/shm.h>
      31             : #else
      32             : #include "tsrm_win32.h"
      33             : #endif
      34             : 
      35             : 
      36             : #if HAVE_SHMOP
      37             : 
      38             : #include "ext/standard/info.h"
      39             : 
      40             : #ifdef ZTS
      41             : int shmop_globals_id;
      42             : #else
      43             : php_shmop_globals shmop_globals;
      44             : #endif
      45             : 
      46             : int shm_type;
      47             : 
      48             : /* {{{ arginfo */
      49             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_open, 0, 0, 4)
      50             :         ZEND_ARG_INFO(0, key)
      51             :         ZEND_ARG_INFO(0, flags)
      52             :         ZEND_ARG_INFO(0, mode)
      53             :         ZEND_ARG_INFO(0, size)
      54             : ZEND_END_ARG_INFO()
      55             : 
      56             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_read, 0, 0, 3)
      57             :         ZEND_ARG_INFO(0, shmid)
      58             :         ZEND_ARG_INFO(0, start)
      59             :         ZEND_ARG_INFO(0, count)
      60             : ZEND_END_ARG_INFO()
      61             : 
      62             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_close, 0, 0, 1)
      63             :         ZEND_ARG_INFO(0, shmid)
      64             : ZEND_END_ARG_INFO()
      65             : 
      66             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_size, 0, 0, 1)
      67             :         ZEND_ARG_INFO(0, shmid)
      68             : ZEND_END_ARG_INFO()
      69             : 
      70             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_write, 0, 0, 3)
      71             :         ZEND_ARG_INFO(0, shmid)
      72             :         ZEND_ARG_INFO(0, data)
      73             :         ZEND_ARG_INFO(0, offset)
      74             : ZEND_END_ARG_INFO()
      75             : 
      76             : ZEND_BEGIN_ARG_INFO_EX(arginfo_shmop_delete, 0, 0, 1)
      77             :         ZEND_ARG_INFO(0, shmid)
      78             : ZEND_END_ARG_INFO()
      79             : /* }}} */
      80             : 
      81             : /* {{{ shmop_functions[] 
      82             :  */
      83             : const zend_function_entry shmop_functions[] = {
      84             :         PHP_FE(shmop_open,              arginfo_shmop_open)
      85             :         PHP_FE(shmop_read,              arginfo_shmop_read)
      86             :         PHP_FE(shmop_close,     arginfo_shmop_close)
      87             :         PHP_FE(shmop_size,              arginfo_shmop_size)
      88             :         PHP_FE(shmop_write,     arginfo_shmop_write)
      89             :         PHP_FE(shmop_delete,    arginfo_shmop_delete)
      90             :         PHP_FE_END
      91             : };
      92             : /* }}} */
      93             : 
      94             : /* {{{ shmop_module_entry
      95             :  */
      96             : zend_module_entry shmop_module_entry = {
      97             :         STANDARD_MODULE_HEADER,
      98             :         "shmop",
      99             :         shmop_functions,
     100             :         PHP_MINIT(shmop),
     101             :         NULL,
     102             :         NULL,
     103             :         NULL,
     104             :         PHP_MINFO(shmop),
     105             :         NO_VERSION_YET,
     106             :         STANDARD_MODULE_PROPERTIES
     107             : };
     108             : /* }}} */
     109             : 
     110             : #ifdef COMPILE_DL_SHMOP
     111             : ZEND_GET_MODULE(shmop)
     112             : #endif
     113             : 
     114             : /* {{{ rsclean
     115             :  */
     116           3 : static void rsclean(zend_resource *rsrc TSRMLS_DC)
     117             : {
     118           3 :         struct php_shmop *shmop = (struct php_shmop *)rsrc->ptr;
     119             : 
     120           3 :         shmdt(shmop->addr);
     121           3 :         efree(shmop);
     122           3 : }
     123             : /* }}} */
     124             : 
     125             : /* {{{ PHP_MINIT_FUNCTION
     126             :  */
     127       20352 : PHP_MINIT_FUNCTION(shmop)
     128             : {
     129       20352 :         shm_type = zend_register_list_destructors_ex(rsclean, NULL, "shmop", module_number);
     130             :         
     131       20352 :         return SUCCESS;
     132             : }
     133             : /* }}} */
     134             : 
     135             : /* {{{ PHP_MINFO_FUNCTION
     136             :  */
     137         143 : PHP_MINFO_FUNCTION(shmop)
     138             : {
     139         143 :         php_info_print_table_start();
     140         143 :         php_info_print_table_row(2, "shmop support", "enabled");
     141         143 :         php_info_print_table_end();
     142         143 : }
     143             : /* }}} */
     144             : 
     145             : /* {{{ proto int shmop_open (int key, string flags, int mode, int size)
     146             :    gets and attaches a shared memory segment */
     147           3 : PHP_FUNCTION(shmop_open)
     148             : {
     149             :         zend_long key, mode, size;
     150             :         struct php_shmop *shmop;        
     151             :         struct shmid_ds shm;
     152             :         char *flags;
     153             :         size_t flags_len;
     154             : 
     155           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsll", &key, &flags, &flags_len, &mode, &size) == FAILURE) {
     156           0 :                 return;
     157             :         }
     158             : 
     159           3 :         if (flags_len != 1) {
     160           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a valid flag", flags);
     161           0 :                 RETURN_FALSE;
     162             :         }
     163             : 
     164           3 :         shmop = emalloc(sizeof(struct php_shmop));
     165           3 :         memset(shmop, 0, sizeof(struct php_shmop));
     166             : 
     167           3 :         shmop->key = key;
     168           3 :         shmop->shmflg |= mode;
     169             : 
     170           3 :         switch (flags[0]) 
     171             :         {
     172             :                 case 'a':
     173           1 :                         shmop->shmatflg |= SHM_RDONLY;
     174           1 :                         break;
     175             :                 case 'c':
     176           0 :                         shmop->shmflg |= IPC_CREAT;
     177           0 :                         shmop->size = size;
     178           0 :                         break;
     179             :                 case 'n':
     180           1 :                         shmop->shmflg |= (IPC_CREAT | IPC_EXCL);
     181           1 :                         shmop->size = size;
     182           1 :                         break;  
     183             :                 case 'w':
     184             :                         /* noop 
     185             :                                 shm segment is being opened for read & write
     186             :                                 will fail if segment does not exist
     187             :                         */
     188           1 :                         break;
     189             :                 default:
     190           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid access mode");
     191           0 :                         goto err;
     192             :         }
     193             : 
     194           3 :         if (shmop->shmflg & IPC_CREAT && shmop->size < 1) {
     195           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Shared memory segment size must be greater than zero");
     196           0 :                 goto err;
     197             :         }
     198             : 
     199           3 :         shmop->shmid = shmget(shmop->key, shmop->size, shmop->shmflg);
     200           3 :         if (shmop->shmid == -1) {
     201           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to attach or create shared memory segment '%s'", strerror(errno));
     202           0 :                 goto err;
     203             :         }
     204             : 
     205           3 :         if (shmctl(shmop->shmid, IPC_STAT, &shm)) {
     206           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to get shared memory segment information '%s'", strerror(errno));
     207           0 :                 goto err;
     208             :         }       
     209             : 
     210           3 :         shmop->addr = shmat(shmop->shmid, 0, shmop->shmatflg);
     211           3 :         if (shmop->addr == (char*) -1) {
     212           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to attach to shared memory segment '%s'", strerror(errno));
     213           0 :                 goto err;
     214             :         }
     215             : 
     216           3 :         shmop->size = shm.shm_segsz;
     217             : 
     218           3 :         ZEND_REGISTER_RESOURCE(return_value, shmop, shm_type);
     219           3 :         RETURN_LONG(Z_RES_HANDLE_P(return_value));
     220             : err:
     221           0 :         efree(shmop);
     222           0 :         RETURN_FALSE;
     223             : }
     224             : /* }}} */
     225             : 
     226             : /* {{{ proto string shmop_read (int shmid, int start, int count)
     227             :    reads from a shm segment */
     228           3 : PHP_FUNCTION(shmop_read)
     229             : {
     230             :         zend_long shmid, start, count;
     231             :         struct php_shmop *shmop;
     232             :         char *startaddr;
     233             :         int bytes;
     234             :         zend_string *return_string;
     235             : 
     236           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &shmid, &start, &count) == FAILURE) {
     237           0 :                 return;
     238             :         }
     239             : 
     240           3 :         ZEND_FETCH_RESOURCE(shmop, struct php_shmop *, NULL, shmid, "shmop", shm_type);
     241             : 
     242           3 :         if (start < 0 || start > shmop->size) {
     243           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "start is out of range");
     244           0 :                 RETURN_FALSE;
     245             :         }
     246             : 
     247           3 :         if (count < 0 || start > (INT_MAX - count) || start + count > shmop->size) {
     248           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "count is out of range");
     249           0 :                 RETURN_FALSE;
     250             :         }
     251             : 
     252           3 :         startaddr = shmop->addr + start;
     253           3 :         bytes = count ? count : shmop->size - start;
     254             : 
     255           6 :         return_string = zend_string_init(startaddr, bytes, 0);
     256             : 
     257           3 :         RETURN_STR(return_string);
     258             : }
     259             : /* }}} */
     260             : 
     261             : /* {{{ proto void shmop_close (int shmid)
     262             :    closes a shared memory segment */
     263           3 : PHP_FUNCTION(shmop_close)
     264             : {
     265             :         zend_long shmid;
     266             :         zval *res;
     267             : 
     268           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &shmid) == FAILURE) {
     269           0 :                 return;
     270             :         }
     271             : 
     272           3 :         res = zend_hash_index_find(&EG(regular_list), shmid);
     273           3 :         if (res) {
     274           3 :                 zend_list_close(Z_RES_P(res));
     275             :         }
     276             : }
     277             : /* }}} */
     278             : 
     279             : /* {{{ proto int shmop_size (int shmid)
     280             :    returns the shm size */
     281           1 : PHP_FUNCTION(shmop_size)
     282             : {
     283             :         zend_long shmid;
     284             :         struct php_shmop *shmop;
     285             : 
     286           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &shmid) == FAILURE) {
     287           0 :                 return;
     288             :         }
     289             : 
     290           1 :         ZEND_FETCH_RESOURCE(shmop, struct php_shmop *, NULL, shmid, "shmop", shm_type);
     291             : 
     292           1 :         RETURN_LONG(shmop->size);
     293             : }
     294             : /* }}} */
     295             : 
     296             : /* {{{ proto int shmop_write (int shmid, string data, int offset)
     297             :    writes to a shared memory segment */
     298           3 : PHP_FUNCTION(shmop_write)
     299             : {
     300             :         struct php_shmop *shmop;
     301             :         int writesize;
     302             :         zend_long shmid, offset;
     303             :         zend_string *data;
     304             : 
     305           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lSl", &shmid, &data, &offset) == FAILURE) {
     306           0 :                 return;
     307             :         }
     308             : 
     309           3 :         ZEND_FETCH_RESOURCE(shmop, struct php_shmop *, NULL, shmid, "shmop", shm_type);
     310             : 
     311           3 :         if ((shmop->shmatflg & SHM_RDONLY) == SHM_RDONLY) {
     312           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "trying to write to a read only segment");
     313           1 :                 RETURN_FALSE;
     314             :         }
     315             : 
     316           2 :         if (offset < 0 || offset > shmop->size) {
     317           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset out of range");
     318           0 :                 RETURN_FALSE;
     319             :         }
     320             : 
     321           2 :         writesize = (data->len < shmop->size - offset) ? data->len : shmop->size - offset;
     322           2 :         memcpy(shmop->addr + offset, data->val, writesize);
     323             : 
     324           2 :         RETURN_LONG(writesize);
     325             : }
     326             : /* }}} */
     327             : 
     328             : /* {{{ proto bool shmop_delete (int shmid)
     329             :    mark segment for deletion */
     330           1 : PHP_FUNCTION(shmop_delete)
     331             : {
     332             :         zend_long shmid;
     333             :         struct php_shmop *shmop;
     334             : 
     335           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &shmid) == FAILURE) {
     336           0 :                 return;
     337             :         }
     338             : 
     339           1 :         ZEND_FETCH_RESOURCE(shmop, struct php_shmop *, NULL, shmid, "shmop", shm_type);
     340             : 
     341           1 :         if (shmctl(shmop->shmid, IPC_RMID, NULL)) {
     342           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "can't mark segment for deletion (are you the owner?)");
     343           0 :                 RETURN_FALSE;
     344             :         }
     345             : 
     346           1 :         RETURN_TRUE;
     347             : }
     348             : /* }}} */
     349             : 
     350             : #endif  /* HAVE_SHMOP */
     351             : 
     352             : /*
     353             :  * Local variables:
     354             :  * tab-width: 4
     355             :  * c-basic-offset: 4
     356             :  * End:
     357             :  * vim600: sw=4 ts=4 fdm=marker
     358             :  * vim<600: sw=4 ts=4
     359             :  */

Generated by: LCOV version 1.10

Generated at Sat, 27 Sep 2014 16:43:16 +0000 (4 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.