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/dba/libinifile - inifile.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 202 269 75.1 %
Date: 2014-07-21 Functions: 23 25 92.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             :    | Author: Marcus Boerger <helly@php.net>                               |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : /* $Id: 218037ebe34b52fdf108d419761cf92785902392 $ */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include "config.h"
      23             : #endif
      24             : 
      25             : #include "php.h"
      26             : #include "php_globals.h"
      27             : 
      28             : #include <stdlib.h>
      29             : #include <string.h>
      30             : #include <errno.h>
      31             : #if HAVE_UNISTD_H
      32             : #include <unistd.h>
      33             : #endif
      34             : 
      35             : #include "inifile.h"
      36             : 
      37             : /* ret = -1 means that database was opened for read-only
      38             :  * ret = 0  success
      39             :  * ret = 1  key already exists - nothing done
      40             :  */
      41             : 
      42             : /* {{{ inifile_version */
      43           2 : char *inifile_version() 
      44             : {
      45           2 :         return "1.0, $Id: 218037ebe34b52fdf108d419761cf92785902392 $";
      46             : }
      47             : /* }}} */ 
      48             : 
      49             : /* {{{ inifile_free_key */
      50         322 : void inifile_key_free(key_type *key)
      51             : {
      52         322 :         if (key->group) {
      53         142 :                 efree(key->group);
      54             :         }
      55         322 :         if (key->name) {
      56         134 :                 efree(key->name);
      57             :         }
      58         322 :         memset(key, 0, sizeof(key_type));
      59         322 : }
      60             : /* }}} */
      61             : 
      62             : /* {{{ inifile_free_val */
      63         529 : void inifile_val_free(val_type *val)
      64             : {
      65         529 :         if (val->value) {
      66         215 :                 efree(val->value);
      67             :         }
      68         529 :         memset(val, 0, sizeof(val_type));
      69         529 : }
      70             : /* }}} */
      71             : 
      72             : /* {{{ inifile_free_val */
      73         265 : void inifile_line_free(line_type *ln)
      74             : {
      75         265 :         inifile_key_free(&ln->key);
      76         265 :         inifile_val_free(&ln->val);
      77         265 :         ln->pos = 0;
      78         265 : }
      79             : /* }}} */
      80             : 
      81             : /* {{{ inifile_alloc */
      82          20 : inifile * inifile_alloc(php_stream *fp, int readonly, int persistent TSRMLS_DC)
      83             : {
      84             :         inifile *dba;
      85             : 
      86          20 :         if (!readonly) {
      87           5 :                 if (!php_stream_truncate_supported(fp)) {
      88           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't truncate this stream");
      89           0 :                         return NULL;
      90             :                 }
      91             :         }
      92             :  
      93          20 :         dba = pemalloc(sizeof(inifile), persistent);
      94          20 :         memset(dba, 0, sizeof(inifile));
      95          20 :         dba->fp = fp;
      96          20 :         dba->readonly = readonly;
      97          20 :         return dba;
      98             : }
      99             : /* }}} */
     100             : 
     101             : /* {{{ inifile_free */
     102          20 : void inifile_free(inifile *dba, int persistent)
     103             : {
     104          20 :         if (dba) {
     105          20 :                 inifile_line_free(&dba->curr);
     106          20 :                 inifile_line_free(&dba->next);
     107          20 :                 pefree(dba, persistent);
     108             :         }
     109          20 : }
     110             : /* }}} */
     111             : 
     112             : /* {{{ inifile_key_split */
     113          57 : key_type inifile_key_split(const char *group_name)
     114             : {
     115             :         key_type key;
     116             :         char *name;
     117             :         
     118          57 :         if (group_name[0] == '[' && (name = strchr(group_name, ']')) != NULL) {
     119           0 :                 key.group = estrndup(group_name+1, name - (group_name + 1));
     120           0 :                 key.name = estrdup(name+1);
     121             :         } else {
     122          57 :                 key.group = estrdup("");
     123          57 :                 key.name = estrdup(group_name);
     124             :         }
     125          57 :         return key;
     126             : }
     127             : /* }}} */
     128             : 
     129             : /* {{{ inifile_key_string */
     130          14 : char * inifile_key_string(const key_type *key)
     131             : {
     132          14 :         if (key->group && *key->group) {
     133             :                 char *result;
     134           0 :                 spprintf(&result, 0, "[%s]%s", key->group, key->name ? key->name : "");
     135           0 :                 return result;
     136          14 :         } else if (key->name) {
     137          14 :                 return estrdup(key->name);
     138             :         } else {
     139           0 :                 return NULL;
     140             :         }
     141             : }
     142             : /* }}} */
     143             : 
     144             : /* {{{ etrim */
     145         416 : static char *etrim(const char *str)
     146             : {
     147             :         char *val;
     148             :         size_t l;
     149             :         
     150         416 :         if (!str) {
     151           0 :                 return NULL;
     152             :         }
     153         416 :         val = (char*)str;
     154         832 :         while (*val && strchr(" \t\r\n", *val)) {
     155           0 :                 val++;
     156             :         }
     157         416 :         l = strlen(val);
     158        1040 :         while (l && (strchr(" \t\r\n", val[l-1]))) {
     159         208 :                 l--;
     160             :         }
     161         416 :         return estrndup(val, l);
     162             : }
     163             : /* }}} */
     164             : 
     165             : /* {{{ inifile_findkey
     166             :  */
     167         257 : static int inifile_read(inifile *dba, line_type *ln TSRMLS_DC) {
     168             :         char *fline;
     169             :         char *pos;
     170             : 
     171         257 :         inifile_val_free(&ln->val);
     172         514 :         while ((fline = php_stream_gets(dba->fp, NULL, 0)) != NULL) {
     173         208 :                 if (fline) {
     174         208 :                         if (fline[0] == '[') {
     175             :                                 /* A value name cannot start with '['
     176             :                                  * So either we find a ']' or we found an error
     177             :                                  */
     178           0 :                                 pos = strchr(fline+1, ']');
     179           0 :                                 if (pos) {
     180           0 :                                         *pos = '\0';
     181           0 :                                         inifile_key_free(&ln->key);
     182           0 :                                         ln->key.group = etrim(fline+1);
     183           0 :                                         ln->key.name = estrdup("");
     184           0 :                                         ln->pos = php_stream_tell(dba->fp);
     185           0 :                                         efree(fline);
     186           0 :                                         return 1;
     187             :                                 } else {
     188           0 :                                         efree(fline);
     189           0 :                                         continue;
     190             :                                 }
     191             :                         } else {
     192         208 :                                 pos = strchr(fline, '=');
     193         208 :                                 if (pos) {
     194         208 :                                         *pos = '\0';
     195             :                                         /* keep group or make empty if not existent */
     196         208 :                                         if (!ln->key.group) {
     197          38 :                                                 ln->key.group = estrdup("");
     198             :                                         }
     199         208 :                                         if (ln->key.name) {
     200         131 :                                                 efree(ln->key.name);
     201             :                                         }
     202         208 :                                         ln->key.name = etrim(fline);
     203         208 :                                         ln->val.value = etrim(pos+1);
     204         208 :                                         ln->pos = php_stream_tell(dba->fp);
     205         208 :                                         efree(fline);
     206         208 :                                         return 1;
     207             :                                 } else {
     208             :                                         /* simply ignore lines without '='
     209             :                                          * those should be comments
     210             :                                          */
     211           0 :                                          efree(fline);
     212           0 :                                          continue;
     213             :                                 }
     214             :                         }
     215             :                 }
     216             :         }
     217          49 :         inifile_line_free(ln);
     218          49 :         return 0;
     219             : }
     220             : /* }}} */
     221             : 
     222             : /* {{{ inifile_key_cmp */
     223             : /* 0 = EQUAL
     224             :  * 1 = GROUP-EQUAL,NAME-DIFFERENT
     225             :  * 2 = DIFFERENT
     226             :  */
     227         194 : static int inifile_key_cmp(const key_type *k1, const key_type *k2 TSRMLS_DC)
     228             : {
     229             :         assert(k1->group && k1->name && k2->group && k2->name);
     230             :         
     231         194 :         if (!strcasecmp(k1->group, k2->group)) {
     232         194 :                 if (!strcasecmp(k1->name, k2->name)) {
     233          54 :                         return 0;
     234             :                 } else {
     235         140 :                         return 1;
     236             :                 }
     237             :         } else {
     238           0 :                 return 2;
     239             :         }
     240             : }
     241             : /* }}} */
     242             : 
     243             : /* {{{ inifile_fetch
     244             :  */
     245          28 : val_type inifile_fetch(inifile *dba, const key_type *key, int skip TSRMLS_DC) {
     246          28 :         line_type ln = {{NULL,NULL},{NULL}};
     247             :         val_type val;
     248          28 :         int res, grp_eq = 0;
     249             : 
     250          28 :         if (skip == -1 && dba->next.key.group && dba->next.key.name && !inifile_key_cmp(&dba->next.key, key TSRMLS_CC)) {
     251             :                 /* we got position already from last fetch */
     252           0 :                 php_stream_seek(dba->fp, dba->next.pos, SEEK_SET);
     253             :         } else {
     254             :                 /* specific instance or not same key -> restart search */
     255             :                 /* the slow way: restart and seacrch */
     256          28 :                 php_stream_rewind(dba->fp);
     257          28 :                 inifile_line_free(&dba->next);
     258             :         }
     259          28 :         if (skip == -1) {
     260           0 :                 skip = 0;
     261             :         }
     262          96 :         while(inifile_read(dba, &ln TSRMLS_CC)) {
     263          63 :                 if (!(res=inifile_key_cmp(&ln.key, key TSRMLS_CC))) {
     264          23 :                         if (!skip) {
     265          23 :                                 val.value = estrdup(ln.val.value ? ln.val.value : "");
     266             :                                 /* allow faster access by updating key read into next */
     267          23 :                                 inifile_line_free(&dba->next);
     268          23 :                                 dba->next = ln;
     269          23 :                                 dba->next.pos = php_stream_tell(dba->fp);
     270          23 :                                 return val;
     271             :                         }
     272           0 :                         skip--;
     273          40 :                 } else if (res == 1) {
     274          40 :                         grp_eq = 1;
     275           0 :                 } else if (grp_eq) {
     276             :                         /* we are leaving group now: that means we cannot find the key */
     277           0 :                         break;
     278             :                 }
     279             :         }
     280           5 :         inifile_line_free(&ln);
     281           5 :         dba->next.pos = php_stream_tell(dba->fp);
     282           5 :         return ln.val;
     283             : }
     284             : /* }}} */
     285             : 
     286             : /* {{{ inifile_firstkey
     287             :  */
     288           4 : int inifile_firstkey(inifile *dba TSRMLS_DC) {
     289           4 :         inifile_line_free(&dba->curr);
     290           4 :         dba->curr.pos = 0;
     291           4 :         return inifile_nextkey(dba TSRMLS_CC);
     292             : }
     293             : /* }}} */
     294             : 
     295             : /* {{{ inifile_nextkey
     296             :  */
     297          18 : int inifile_nextkey(inifile *dba TSRMLS_DC) {
     298          18 :         line_type ln = {{NULL,NULL},{NULL}};
     299             : 
     300             :         /*inifile_line_free(&dba->next); ??? */
     301          18 :         php_stream_seek(dba->fp, dba->curr.pos, SEEK_SET);
     302          18 :         ln.key.group = estrdup(dba->curr.key.group ? dba->curr.key.group : "");
     303          18 :         inifile_read(dba, &ln TSRMLS_CC);
     304          18 :         inifile_line_free(&dba->curr);
     305          18 :         dba->curr = ln;
     306          18 :         return ln.key.group || ln.key.name;
     307             : }       
     308             : /* }}} */
     309             : 
     310             : /* {{{ inifile_truncate
     311             :  */
     312          29 : static int inifile_truncate(inifile *dba, size_t size TSRMLS_DC)
     313             : {
     314             :         int res;
     315             : 
     316          29 :         if ((res=php_stream_truncate_set_size(dba->fp, size)) != 0) {
     317           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error in ftruncate: %d", res);
     318           0 :                 return FAILURE;
     319             :         }
     320          29 :         php_stream_seek(dba->fp, size, SEEK_SET);
     321          29 :         return SUCCESS;
     322             : }
     323             : /* }}} */
     324             : 
     325             : /* {{{ inifile_find_group
     326             :  * if found pos_grp_start points to "[group_name]"
     327             :  */
     328          29 : static int inifile_find_group(inifile *dba, const key_type *key, size_t *pos_grp_start TSRMLS_DC) 
     329             : {
     330          29 :         int ret = FAILURE;
     331             : 
     332          29 :         php_stream_flush(dba->fp);
     333          29 :         php_stream_seek(dba->fp, 0, SEEK_SET);
     334          29 :         inifile_line_free(&dba->curr);
     335          29 :         inifile_line_free(&dba->next);
     336             : 
     337          29 :         if (key->group && strlen(key->group)) {
     338             :                 int res;
     339           0 :                 line_type ln = {{NULL,NULL},{NULL}};
     340             : 
     341           0 :                 res = 1;
     342           0 :                 while(inifile_read(dba, &ln TSRMLS_CC)) {
     343           0 :                         if ((res=inifile_key_cmp(&ln.key, key TSRMLS_CC)) < 2) {
     344           0 :                                 ret = SUCCESS;
     345           0 :                                 break;
     346             :                         }
     347           0 :                         *pos_grp_start = php_stream_tell(dba->fp);
     348             :                 }
     349           0 :                 inifile_line_free(&ln);
     350             :         } else {
     351          29 :                 *pos_grp_start = 0;
     352          29 :                 ret = SUCCESS;
     353             :         }
     354          29 :         if (ret == FAILURE) {
     355           0 :                 *pos_grp_start = php_stream_tell(dba->fp);
     356             :         }
     357          29 :         return ret;
     358             : }
     359             : /* }}} */
     360             : 
     361             : /* {{{ inifile_next_group
     362             :  * only valid after a call to inifile_find_group
     363             :  * if any next group is found pos_grp_start points to "[group_name]" or whitespace before that
     364             :  */
     365          29 : static int inifile_next_group(inifile *dba, const key_type *key, size_t *pos_grp_start TSRMLS_DC) 
     366             : {
     367          29 :         int ret = FAILURE;
     368          29 :         line_type ln = {{NULL,NULL},{NULL}};
     369             : 
     370          29 :         *pos_grp_start = php_stream_tell(dba->fp);
     371          29 :         ln.key.group = estrdup(key->group);
     372         142 :         while(inifile_read(dba, &ln TSRMLS_CC)) {
     373          84 :                 if (inifile_key_cmp(&ln.key, key TSRMLS_CC) == 2) {
     374           0 :                         ret = SUCCESS;
     375           0 :                         break;
     376             :                 }
     377          84 :                 *pos_grp_start = php_stream_tell(dba->fp);
     378             :         }
     379          29 :         inifile_line_free(&ln);
     380          29 :         return ret;
     381             : }
     382             : /* }}} */
     383             : 
     384             : /* {{{ inifile_copy_to
     385             :  */
     386          12 : static int inifile_copy_to(inifile *dba, size_t pos_start, size_t pos_end, inifile **ini_copy TSRMLS_DC)
     387             : {
     388             :         php_stream *fp;
     389             :         
     390          12 :         if (pos_start == pos_end) {
     391           1 :                 *ini_copy = NULL;
     392           1 :                 return SUCCESS;
     393             :         }
     394          11 :         if ((fp = php_stream_temp_create(0, 64 * 1024)) == NULL) {
     395           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not create temporary stream");
     396           0 :                 *ini_copy = NULL;
     397           0 :                 return FAILURE;
     398             :         }
     399             : 
     400          11 :         if ((*ini_copy = inifile_alloc(fp, 1, 0 TSRMLS_CC)) == NULL) {
     401             :                 /* writes error */
     402           0 :                 return FAILURE;
     403             :         }
     404          11 :         php_stream_seek(dba->fp, pos_start, SEEK_SET);
     405          11 :         if (SUCCESS != php_stream_copy_to_stream_ex(dba->fp, fp, pos_end - pos_start, NULL)) {
     406           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not copy group [%zu - %zu] to temporary stream", pos_start, pos_end);
     407           0 :                 return FAILURE;
     408             :         } 
     409          11 :         return SUCCESS;
     410             : }
     411             : /* }}} */
     412             : 
     413             : /* {{{ inifile_filter
     414             :  * copy from to dba while ignoring key name (group must equal)
     415             :  */
     416          11 : static int inifile_filter(inifile *dba, inifile *from, const key_type *key, zend_bool *found TSRMLS_DC)
     417             : {
     418          11 :         size_t pos_start = 0, pos_next = 0, pos_curr;
     419          11 :         int ret = SUCCESS;
     420          11 :         line_type ln = {{NULL,NULL},{NULL}};
     421             : 
     422          11 :         php_stream_seek(from->fp, 0, SEEK_SET);
     423          11 :         php_stream_seek(dba->fp, 0, SEEK_END);
     424          69 :         while(inifile_read(from, &ln TSRMLS_CC)) {
     425          47 :                 switch(inifile_key_cmp(&ln.key, key TSRMLS_CC)) {
     426             :                 case 0:
     427          13 :                         if (found) {
     428           9 :                                 *found = (zend_bool) 1;
     429             :                         }
     430          13 :                         pos_curr = php_stream_tell(from->fp);
     431          13 :                         if (pos_start != pos_next) {
     432           4 :                                 php_stream_seek(from->fp, pos_start, SEEK_SET);
     433           4 :                                 if (SUCCESS != php_stream_copy_to_stream_ex(from->fp, dba->fp, pos_next - pos_start, NULL)) {
     434           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not copy [%zu - %zu] from temporary stream", pos_next, pos_start);
     435           0 :                                         ret = FAILURE;
     436             :                                 }
     437           4 :                                 php_stream_seek(from->fp, pos_curr, SEEK_SET);
     438             :                         }
     439          13 :                         pos_next = pos_start = pos_curr;
     440          13 :                         break;
     441             :                 case 1:
     442          34 :                         pos_next = php_stream_tell(from->fp);
     443             :                         break;
     444             :                 case 2:
     445             :                         /* the function is meant to process only entries from same group */
     446             :                         assert(0);
     447             :                         break;
     448             :                 }
     449             :         }
     450          11 :         if (pos_start != pos_next) {
     451          10 :                 php_stream_seek(from->fp, pos_start, SEEK_SET);
     452          10 :                 if (SUCCESS != php_stream_copy_to_stream_ex(from->fp, dba->fp, pos_next - pos_start, NULL)) {
     453           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not copy [%zu - %zu] from temporary stream", pos_next, pos_start);
     454           0 :                         ret = FAILURE;
     455             :                 }
     456             :         }
     457          11 :         inifile_line_free(&ln);
     458          11 :         return ret;
     459             : }
     460             : /* }}} */
     461             : 
     462             : /* {{{ inifile_delete_replace_append
     463             :  */
     464          29 : static int inifile_delete_replace_append(inifile *dba, const key_type *key, const val_type *value, int append, zend_bool *found TSRMLS_DC)
     465             : {
     466          29 :         size_t pos_grp_start=0, pos_grp_next;
     467          29 :         inifile *ini_tmp = NULL;
     468          29 :         php_stream *fp_tmp = NULL;
     469             :         int ret;
     470             : 
     471             :         /* 1) Search group start
     472             :          * 2) Search next group
     473             :          * 3) If not append: Copy group to ini_tmp
     474             :          * 4) Open temp_stream and copy remainder
     475             :          * 5) Truncate stream
     476             :          * 6) If not append AND key.name given: Filtered copy back from ini_tmp 
     477             :          *    to stream. Otherwise the user wanted to delete the group.
     478             :          * 7) Append value if given
     479             :          * 8) Append temporary stream
     480             :          */
     481             : 
     482             :         assert(!append || (key->name && value)); /* missuse */
     483             : 
     484             :         /* 1 - 3 */
     485          29 :         inifile_find_group(dba, key, &pos_grp_start TSRMLS_CC);
     486          29 :         inifile_next_group(dba, key, &pos_grp_next TSRMLS_CC);
     487          29 :         if (append) {
     488          17 :                 ret = SUCCESS;
     489             :         } else {
     490          12 :                 ret = inifile_copy_to(dba, pos_grp_start, pos_grp_next, &ini_tmp TSRMLS_CC);
     491             :         }
     492             : 
     493             :         /* 4 */
     494          29 :         if (ret == SUCCESS) {
     495          29 :                 fp_tmp = php_stream_temp_create(0, 64 * 1024);
     496          29 :                 if (!fp_tmp) {
     497           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not create temporary stream");
     498           0 :                         ret = FAILURE;
     499             :                 } else {
     500          29 :                         php_stream_seek(dba->fp, 0, SEEK_END);
     501          29 :                         if (pos_grp_next != (size_t)php_stream_tell(dba->fp)) {
     502           0 :                                 php_stream_seek(dba->fp, pos_grp_next, SEEK_SET);
     503           0 :                                 if (SUCCESS != php_stream_copy_to_stream_ex(dba->fp, fp_tmp, PHP_STREAM_COPY_ALL, NULL)) {
     504           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not copy remainder to temporary stream");
     505           0 :                                         ret = FAILURE;
     506             :                                 }
     507             :                         }
     508             :                 }
     509             :         }
     510             :         
     511             :         /* 5 */
     512          29 :         if (ret == SUCCESS) {
     513          29 :                 if (!value || (key->name && strlen(key->name))) {
     514          29 :                         ret = inifile_truncate(dba, append ? pos_grp_next : pos_grp_start TSRMLS_CC); /* writes error on fail */
     515             :                 }
     516             :         }
     517             : 
     518          29 :         if (ret == SUCCESS) {
     519          29 :                 if (key->name && strlen(key->name)) {
     520             :                         /* 6 */
     521          29 :                         if (!append && ini_tmp) {
     522          11 :                                 ret = inifile_filter(dba, ini_tmp, key, found TSRMLS_CC);
     523             :                         }
     524             : 
     525             :                         /* 7 */
     526             :                         /* important: do not query ret==SUCCESS again: inifile_filter might fail but
     527             :                          * however next operation must be done.
     528             :                          */
     529          29 :                         if (value) {
     530          21 :                                 if (pos_grp_start == pos_grp_next && key->group && strlen(key->group)) {
     531           0 :                                         php_stream_printf(dba->fp TSRMLS_CC, "[%s]\n", key->group);
     532             :                                 }
     533          21 :                                 php_stream_printf(dba->fp TSRMLS_CC, "%s=%s\n", key->name, value->value ? value->value : "");
     534             :                         }
     535             :                 }
     536             :                 
     537             :                 /* 8 */ 
     538             :                 /* important: do not query ret==SUCCESS again: inifile_filter might fail but
     539             :                  * however next operation must be done.
     540             :                  */
     541          29 :                 if (fp_tmp && php_stream_tell(fp_tmp)) {
     542           0 :                         php_stream_seek(fp_tmp, 0, SEEK_SET);
     543           0 :                         php_stream_seek(dba->fp, 0, SEEK_END);
     544           0 :                         if (SUCCESS != php_stream_copy_to_stream_ex(fp_tmp, dba->fp, PHP_STREAM_COPY_ALL, NULL)) {
     545           0 :                                 php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Could not copy from temporary stream - ini file truncated");
     546           0 :                                 ret = FAILURE;
     547             :                         }
     548             :                 }
     549             :         }
     550             : 
     551          29 :         if (ini_tmp) {
     552          11 :                 php_stream_close(ini_tmp->fp);
     553          11 :                 inifile_free(ini_tmp, 0);
     554             :         }
     555          29 :         if (fp_tmp) {
     556          29 :                 php_stream_close(fp_tmp);
     557             :         }
     558          29 :         php_stream_flush(dba->fp);
     559          29 :         php_stream_seek(dba->fp, 0, SEEK_SET);
     560             : 
     561          29 :         return ret;
     562             : }
     563             : /* }}} */
     564             : 
     565             : /* {{{ inifile_delete
     566             :  */
     567           0 : int inifile_delete(inifile *dba, const key_type *key TSRMLS_DC) 
     568             : {
     569           0 :         return inifile_delete_replace_append(dba, key, NULL, 0, NULL TSRMLS_CC);
     570             : }
     571             : /* }}} */
     572             : 
     573             : /* {{{ inifile_delete_ex
     574             :  */
     575           8 : int inifile_delete_ex(inifile *dba, const key_type *key, zend_bool *found TSRMLS_DC)
     576             : {
     577           8 :         return inifile_delete_replace_append(dba, key, NULL, 0, found TSRMLS_CC);
     578             : }       
     579             : /* }}} */
     580             : 
     581             : /* {{{ inifile_relace
     582             :  */
     583           4 : int inifile_replace(inifile *dba, const key_type *key, const val_type *value TSRMLS_DC) 
     584             : {
     585           4 :         return inifile_delete_replace_append(dba, key, value, 0, NULL TSRMLS_CC);
     586             : }
     587             : /* }}} */
     588             : 
     589             : /* {{{ inifile_replace_ex
     590             :  */
     591           0 : int inifile_replace_ex(inifile *dba, const key_type *key, const val_type *value, zend_bool *found TSRMLS_DC)
     592             : {
     593           0 :         return inifile_delete_replace_append(dba, key, value, 0, found TSRMLS_CC);
     594             : }
     595             : /* }}} */
     596             : 
     597             : /* {{{ inifile_append
     598             :  */
     599          17 : int inifile_append(inifile *dba, const key_type *key, const val_type *value TSRMLS_DC) 
     600             : {
     601          17 :         return inifile_delete_replace_append(dba, key, value, 1, NULL TSRMLS_CC);
     602             : }
     603             : /* }}} */
     604             : 
     605             : /*
     606             :  * Local variables:
     607             :  * tab-width: 4
     608             :  * c-basic-offset: 4
     609             :  * End:
     610             :  * vim600: sw=4 ts=4 fdm=marker
     611             :  * vim<600: sw=4 ts=4
     612             :  */

Generated by: LCOV version 1.10

Generated at Tue, 22 Jul 2014 01:33:08 +0000 (13 hours ago)

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