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: 197 262 75.2 %
Date: 2014-04-08 Functions: 23 23 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Tue, 08 Apr 2014 11:59:36 +0000 (8 days ago)

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