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/libflatfile - flatfile.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 116 150 77.3 %
Date: 2015-07-05 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2015 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Marcus Boerger <helly@php.net>                              |
      16             :    | based on ext/db/db.c by:                                             |
      17             :    |          Rasmus Lerdorf <rasmus@php.net>                             |
      18             :    |          Jim Winstead <jimw@php.net>                                 |
      19             :    +----------------------------------------------------------------------+
      20             :  */
      21             : 
      22             : /* $Id: f640e19334ad4faafadf5af1eaebba6c6dcc1d1f $ */
      23             : 
      24             : #ifdef HAVE_CONFIG_H
      25             : #include "config.h"
      26             : #endif
      27             : 
      28             : #include "php.h"
      29             : #include "php_globals.h"
      30             : 
      31             : #include <stdlib.h>
      32             : #include <string.h>
      33             : #include <errno.h>
      34             : #if HAVE_UNISTD_H
      35             : #include <unistd.h>
      36             : #endif
      37             : 
      38             : #include "flatfile.h"
      39             : 
      40             : #define FLATFILE_BLOCK_SIZE 1024
      41             : 
      42             : /*
      43             :  * ret = -1 means that database was opened for read-only
      44             :  * ret = 0  success
      45             :  * ret = 1  key already exists - nothing done
      46             :  */
      47             : 
      48             : /* {{{ flatfile_store
      49             :  */
      50          70 : int flatfile_store(flatfile *dba, datum key_datum, datum value_datum, int mode) {
      51          70 :         if (mode == FLATFILE_INSERT) {
      52          61 :                 if (flatfile_findkey(dba, key_datum)) {
      53           4 :                         return 1;
      54             :                 }
      55          57 :                 php_stream_seek(dba->fp, 0L, SEEK_END);
      56          57 :                 php_stream_printf(dba->fp, "%zu\n", key_datum.dsize);
      57          57 :                 php_stream_flush(dba->fp);
      58          57 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      59           0 :                         return -1;
      60             :                 }
      61          57 :                 php_stream_printf(dba->fp, "%zu\n", value_datum.dsize);
      62          57 :                 php_stream_flush(dba->fp);
      63          57 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      64           0 :                         return -1;
      65             :                 }
      66             :         } else { /* FLATFILE_REPLACE */
      67           9 :                 flatfile_delete(dba, key_datum);
      68           9 :                 php_stream_printf(dba->fp, "%zu\n", key_datum.dsize);
      69           9 :                 php_stream_flush(dba->fp);
      70           9 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      71           0 :                         return -1;
      72             :                 }
      73           9 :                 php_stream_printf(dba->fp, "%zu\n", value_datum.dsize);
      74           9 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      75           0 :                         return -1;
      76             :                 }
      77             :         }
      78             : 
      79          66 :         php_stream_flush(dba->fp);
      80          66 :         return 0;
      81             : }
      82             : /* }}} */
      83             : 
      84             : /* {{{ flatfile_fetch
      85             :  */
      86          89 : datum flatfile_fetch(flatfile *dba, datum key_datum) {
      87          89 :         datum value_datum = {NULL, 0};
      88             :         char buf[16];
      89             : 
      90          89 :         if (flatfile_findkey(dba, key_datum)) {
      91          78 :                 if (php_stream_gets(dba->fp, buf, sizeof(buf))) {
      92          78 :                         value_datum.dsize = atoi(buf);
      93          78 :                         value_datum.dptr = safe_emalloc(value_datum.dsize, 1, 1);
      94          78 :                         value_datum.dsize = php_stream_read(dba->fp, value_datum.dptr, value_datum.dsize);
      95             :                 } else {
      96           0 :                         value_datum.dptr = NULL;
      97           0 :                         value_datum.dsize = 0;
      98             :                 }
      99             :         }
     100          89 :         return value_datum;
     101             : }
     102             : /* }}} */
     103             : 
     104             : /* {{{ flatfile_delete
     105             :  */
     106          23 : int flatfile_delete(flatfile *dba, datum key_datum) {
     107          23 :         char *key = key_datum.dptr;
     108          23 :         size_t size = key_datum.dsize;
     109          23 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     110          23 :         char *buf = emalloc(buf_size);
     111             :         size_t num;
     112             :         size_t pos;
     113             : 
     114          23 :         php_stream_rewind(dba->fp);
     115          92 :         while(!php_stream_eof(dba->fp)) {
     116             :                 /* read in the length of the key name */
     117          69 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     118           0 :                         break;
     119             :                 }
     120          69 :                 num = atoi(buf);
     121          69 :                 if (num >= buf_size) {
     122           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     123           0 :                         buf = erealloc(buf, buf_size);
     124             :                 }
     125          69 :                 pos = php_stream_tell(dba->fp);
     126             : 
     127             :                 /* read in the key name */
     128          69 :                 num = php_stream_read(dba->fp, buf, num);
     129             : 
     130          69 :                 if (size == num && !memcmp(buf, key, size)) {
     131          23 :                         php_stream_seek(dba->fp, pos, SEEK_SET);
     132          23 :                         php_stream_putc(dba->fp, 0);
     133          23 :                         php_stream_flush(dba->fp);
     134          23 :                         php_stream_seek(dba->fp, 0L, SEEK_END);
     135          23 :                         efree(buf);
     136          23 :                         return SUCCESS;
     137             :                 }
     138             : 
     139             :                 /* read in the length of the value */
     140          46 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     141           0 :                         break;
     142             :                 }
     143          46 :                 num = atoi(buf);
     144          46 :                 if (num >= buf_size) {
     145           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     146           0 :                         buf = erealloc(buf, buf_size);
     147             :                 }
     148             :                 /* read in the value */
     149          46 :                 num = php_stream_read(dba->fp, buf, num);
     150             :         }
     151           0 :         efree(buf);
     152           0 :         return FAILURE;
     153             : }
     154             : /* }}} */
     155             : 
     156             : /* {{{ flatfile_findkey
     157             :  */
     158         150 : int flatfile_findkey(flatfile *dba, datum key_datum) {
     159         150 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     160         150 :         char *buf = emalloc(buf_size);
     161             :         size_t num;
     162         150 :         int ret=0;
     163         150 :         void *key = key_datum.dptr;
     164         150 :         size_t size = key_datum.dsize;
     165             : 
     166         150 :         php_stream_rewind(dba->fp);
     167         709 :         while (!php_stream_eof(dba->fp)) {
     168         559 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     169          68 :                         break;
     170             :                 }
     171         491 :                 num = atoi(buf);
     172         491 :                 if (num >= buf_size) {
     173           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     174           0 :                         buf = erealloc(buf, buf_size);
     175             :                 }
     176         491 :                 num = php_stream_read(dba->fp, buf, num);
     177             : 
     178         491 :                 if (size == num) {
     179         377 :                         if (!memcmp(buf, key, size)) {
     180          82 :                                 ret = 1;
     181          82 :                                 break;
     182             :                         }
     183             :                 }
     184         409 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     185           0 :                         break;
     186             :                 }
     187         409 :                 num = atoi(buf);
     188         409 :                 if (num >= buf_size) {
     189           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     190           0 :                         buf = erealloc(buf, buf_size);
     191             :                 }
     192         409 :                 num = php_stream_read(dba->fp, buf, num);
     193             :         }
     194         150 :         efree(buf);
     195         150 :         return ret;
     196             : }
     197             : /* }}} */
     198             : 
     199             : /* {{{ flatfile_firstkey
     200             :  */
     201          13 : datum flatfile_firstkey(flatfile *dba) {
     202             :         datum res;
     203             :         size_t num;
     204          13 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     205          13 :         char *buf = emalloc(buf_size);
     206             : 
     207          13 :         php_stream_rewind(dba->fp);
     208          47 :         while(!php_stream_eof(dba->fp)) {
     209          34 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     210           0 :                         break;
     211             :                 }
     212          34 :                 num = atoi(buf);
     213          34 :                 if (num >= buf_size) {
     214           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     215           0 :                         buf = erealloc(buf, buf_size);
     216             :                 }
     217          34 :                 num = php_stream_read(dba->fp, buf, num);
     218             : 
     219          34 :                 if (*(buf) != 0) {
     220          13 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     221          13 :                         res.dptr = buf;
     222          13 :                         res.dsize = num;
     223          13 :                         return res;
     224             :                 }
     225          21 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     226           0 :                         break;
     227             :                 }
     228          21 :                 num = atoi(buf);
     229          21 :                 if (num >= buf_size) {
     230           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     231           0 :                         buf = erealloc(buf, buf_size);
     232             :                 }
     233          21 :                 num = php_stream_read(dba->fp, buf, num);
     234             :         }
     235           0 :         efree(buf);
     236           0 :         res.dptr = NULL;
     237           0 :         res.dsize = 0;
     238           0 :         return res;
     239             : }
     240             : /* }}} */
     241             : 
     242             : /* {{{ flatfile_nextkey
     243             :  */
     244          42 : datum flatfile_nextkey(flatfile *dba) {
     245             :         datum res;
     246             :         size_t num;
     247          42 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     248          42 :         char *buf = emalloc(buf_size);
     249             : 
     250          42 :         php_stream_seek(dba->fp, dba->CurrentFlatFilePos, SEEK_SET);
     251          42 :         while(!php_stream_eof(dba->fp)) {
     252          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     253           0 :                         break;
     254             :                 }
     255          51 :                 num = atoi(buf);
     256          51 :                 if (num >= buf_size) {
     257           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     258           0 :                         buf = erealloc(buf, buf_size);
     259             :                 }
     260          51 :                 num = php_stream_read(dba->fp, buf, num);
     261             : 
     262          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     263          13 :                         break;
     264             :                 }
     265          38 :                 num = atoi(buf);
     266          38 :                 if (num >= buf_size) {
     267           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     268           0 :                         buf = erealloc(buf, buf_size);
     269             :                 }
     270          38 :                 num = php_stream_read(dba->fp, buf, num);
     271             : 
     272          38 :                 if (*(buf)!=0) {
     273          29 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     274          29 :                         res.dptr = buf;
     275          29 :                         res.dsize = num;
     276          29 :                         return res;
     277             :                 }
     278             :         }
     279          13 :         efree(buf);
     280          13 :         res.dptr = NULL;
     281          13 :         res.dsize = 0;
     282          13 :         return res;
     283             : }
     284             : /* }}} */
     285             : 
     286             : /* {{{ flatfile_version */
     287           2 : char *flatfile_version()
     288             : {
     289           2 :         return "1.0, $Id: f640e19334ad4faafadf5af1eaebba6c6dcc1d1f $";
     290             : }
     291             : /* }}} */
     292             : 
     293             : /*
     294             :  * Local variables:
     295             :  * tab-width: 4
     296             :  * c-basic-offset: 4
     297             :  * End:
     298             :  * vim600: sw=4 ts=4 fdm=marker
     299             :  * vim<600: sw=4 ts=4
     300             :  */

Generated by: LCOV version 1.10

Generated at Sun, 05 Jul 2015 15:44:46 +0000 (32 hours ago)

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