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: 226 270 83.7 %
Date: 2016-09-27 Functions: 23 25 92.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Tue, 27 Sep 2016 10:25:55 +0000 (4 days ago)

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