1999-04-19 21:56:50 +08:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
1999-07-16 21:13:16 +08:00
|
|
|
| PHP version 4.0 |
|
1999-04-19 21:56:50 +08:00
|
|
|
+----------------------------------------------------------------------+
|
2001-02-26 14:11:02 +08:00
|
|
|
| Copyright (c) 1997-2001 The PHP Group |
|
1999-04-19 21:56:50 +08:00
|
|
|
+----------------------------------------------------------------------+
|
2000-05-18 23:34:45 +08:00
|
|
|
| This source file is subject to version 2.02 of the PHP license, |
|
1999-07-16 21:13:16 +08:00
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
|
|
| available at through the world-wide-web at |
|
2000-05-18 23:34:45 +08:00
|
|
|
| http://www.php.net/license/2_02.txt. |
|
1999-07-16 21:13:16 +08:00
|
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
|
|
| license@php.net so we can mail you a copy immediately. |
|
1999-04-19 21:56:50 +08:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Authors: Jim Winstead (jimw@php.net) |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
1999-06-28 05:23:17 +08:00
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
|
|
#include <sys/types.h>
|
|
|
|
#endif
|
|
|
|
|
1999-04-19 21:56:50 +08:00
|
|
|
#include "php.h"
|
|
|
|
#include "safe_mode.h"
|
2001-02-24 06:07:16 +08:00
|
|
|
#include "fopen_wrappers.h"
|
1999-04-19 21:56:50 +08:00
|
|
|
#include "php_globals.h"
|
|
|
|
|
|
|
|
#if DBASE
|
1999-05-21 16:20:13 +08:00
|
|
|
#include "php_dbase.h"
|
|
|
|
#include "dbf.h"
|
1999-04-19 21:56:50 +08:00
|
|
|
#if defined(THREAD_SAFE)
|
|
|
|
DWORD DbaseTls;
|
|
|
|
static int numthreads=0;
|
|
|
|
void *dbase_mutex;
|
|
|
|
|
|
|
|
typedef struct dbase_global_struct{
|
|
|
|
int le_dbhead;
|
|
|
|
}dbase_global_struct;
|
|
|
|
|
|
|
|
#define DBase_GLOBAL(a) dbase_globals->a
|
|
|
|
|
|
|
|
#define DBase_TLS_VARS \
|
|
|
|
dbase_global_struct *dbase_globals; \
|
|
|
|
dbase_globals=TlsGetValue(DbaseTls);
|
|
|
|
|
|
|
|
#else
|
|
|
|
static int le_dbhead;
|
|
|
|
#define DBase_GLOBAL(a) a
|
|
|
|
#define DBase_TLS_VARS
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
|
2000-10-21 02:25:16 +08:00
|
|
|
static void _close_dbase(zend_rsrc_list_entry *rsrc)
|
1999-04-19 21:56:50 +08:00
|
|
|
{
|
2000-10-21 02:25:16 +08:00
|
|
|
dbhead_t *dbhead = (dbhead_t *)rsrc->ptr;
|
1999-04-19 21:56:50 +08:00
|
|
|
close(dbhead->db_fd);
|
|
|
|
free_dbf_head(dbhead);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-07-28 01:09:35 +08:00
|
|
|
PHP_MINIT_FUNCTION(dbase)
|
1999-04-19 21:56:50 +08:00
|
|
|
{
|
|
|
|
#if defined(THREAD_SAFE)
|
|
|
|
dbase_global_struct *dbase_globals;
|
2000-05-23 17:33:51 +08:00
|
|
|
#ifdef COMPILE_DL_DBASE
|
1999-04-19 21:56:50 +08:00
|
|
|
CREATE_MUTEX(dbase_mutex,"DBase_TLS");
|
|
|
|
SET_MUTEX(dbase_mutex);
|
|
|
|
numthreads++;
|
|
|
|
if (numthreads==1){
|
|
|
|
if ((DbaseTls=TlsAlloc())==0xFFFFFFFF){
|
|
|
|
FREE_MUTEX(dbase_mutex);
|
|
|
|
return 0;
|
|
|
|
}}
|
|
|
|
FREE_MUTEX(dbase_mutex);
|
|
|
|
#endif
|
|
|
|
dbase_globals = (dbase_global_struct *) LocalAlloc(LPTR, sizeof(dbase_global_struct));
|
|
|
|
TlsSetValue(DbaseTls, (void *) dbase_globals);
|
|
|
|
#endif
|
2000-10-21 02:25:16 +08:00
|
|
|
DBase_GLOBAL(le_dbhead) =
|
2000-10-26 01:44:02 +08:00
|
|
|
zend_register_list_destructors_ex(_close_dbase, NULL, "dbase", module_number);
|
1999-04-19 21:56:50 +08:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
1999-07-28 01:09:35 +08:00
|
|
|
static PHP_MSHUTDOWN_FUNCTION(dbase)
|
|
|
|
{
|
1999-04-19 21:56:50 +08:00
|
|
|
#if defined(THREAD_SAFE)
|
|
|
|
dbase_global_struct *dbase_globals;
|
|
|
|
dbase_globals = TlsGetValue(DbaseTls);
|
|
|
|
if (dbase_globals != 0)
|
|
|
|
LocalFree((HLOCAL) dbase_globals);
|
2000-05-23 17:33:51 +08:00
|
|
|
#ifdef COMPILE_DL_DBASE
|
1999-04-19 21:56:50 +08:00
|
|
|
SET_MUTEX(dbase_mutex);
|
|
|
|
numthreads--;
|
|
|
|
if (!numthreads){
|
|
|
|
if (!TlsFree(DbaseTls)){
|
|
|
|
FREE_MUTEX(dbase_mutex);
|
|
|
|
return 0;
|
|
|
|
}}
|
|
|
|
FREE_MUTEX(dbase_mutex);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* {{{ proto int dbase_open(string name, int mode)
|
|
|
|
Opens a dBase-format database file */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_open) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbf_name, *options;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int handle;
|
1999-12-12 18:51:44 +08:00
|
|
|
PLS_FETCH();
|
1999-04-19 21:56:50 +08:00
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&dbf_name,&options)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_string(dbf_name);
|
|
|
|
convert_to_long(options);
|
|
|
|
|
2000-11-03 07:08:07 +08:00
|
|
|
if (PG(safe_mode) && (!php_checkuid(dbf_name->value.str.val, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-18 03:16:50 +08:00
|
|
|
if (php_check_open_basedir(dbf_name->value.str.val)) {
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbh = dbf_open(dbf_name->value.str.val, options->value.lval);
|
|
|
|
if (dbh == NULL) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to open database %s", dbf_name->value.str.val);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
handle = zend_list_insert(dbh, DBase_GLOBAL(le_dbhead));
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_LONG(handle);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto bool dbase_close(int identifier)
|
|
|
|
Closes an open dBase-format database file */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_close) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 1 || getParameters(ht,1,&dbh_id)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
zend_list_delete(dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbase_numrecords(int identifier)
|
|
|
|
Returns the number of records in the database */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_numrecords) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 1 || getParameters(ht,1,&dbh_id)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(dbh->db_records);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbase_numfields(int identifier)
|
|
|
|
Returns the number of fields (columns) in the database */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_numfields) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 1 || getParameters(ht,1,&dbh_id)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(dbh->db_nfields);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto bool dbase_pack(int identifier)
|
|
|
|
Packs the database (deletes records marked for deletion) */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_pack) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 1 || getParameters(ht,1,&dbh_id)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
pack_dbf(dbh);
|
|
|
|
put_dbf_info(dbh);
|
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto bool dbase_add_record(int identifier, array data)
|
|
|
|
Adds a record to the database */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_add_record) {
|
2000-08-14 01:41:20 +08:00
|
|
|
pval *dbh_id, *fields, **field;
|
1999-04-19 21:56:50 +08:00
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
|
|
|
|
int num_fields;
|
|
|
|
dbfield_t *dbf, *cur_f;
|
|
|
|
char *cp, *t_cp;
|
|
|
|
int i;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&dbh_id,&fields)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
|
|
|
if (fields->type != IS_ARRAY) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Expected array as second parameter");
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-08-03 03:17:14 +08:00
|
|
|
num_fields = zend_hash_num_elements(fields->value.ht);
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
if (num_fields != dbh->db_nfields) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Wrong number of fields specified");
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
cp = t_cp = (char *)emalloc(dbh->db_rlen + 1);
|
|
|
|
if (!cp) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to allocate memory");
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
*t_cp++ = VALID_RECORD;
|
|
|
|
|
|
|
|
dbf = dbh->db_fields;
|
|
|
|
for (i = 0, cur_f = dbf; cur_f < &dbf[num_fields]; i++, cur_f++) {
|
2000-07-23 11:45:24 +08:00
|
|
|
zval tmp;
|
1999-08-03 03:17:14 +08:00
|
|
|
if (zend_hash_index_find(fields->value.ht, i, (void **)&field) == FAILURE) {
|
|
|
|
php_error(E_WARNING, "unexpected error");
|
1999-04-19 21:56:50 +08:00
|
|
|
efree(cp);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-23 11:45:24 +08:00
|
|
|
|
2000-08-14 01:41:20 +08:00
|
|
|
tmp = **field;
|
2000-07-23 11:45:24 +08:00
|
|
|
zval_copy_ctor(&tmp);
|
|
|
|
convert_to_string(&tmp);
|
|
|
|
sprintf(t_cp, cur_f->db_format, tmp.value.str.val);
|
|
|
|
zval_dtor(&tmp);
|
1999-04-19 21:56:50 +08:00
|
|
|
t_cp += cur_f->db_flen;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbh->db_records++;
|
|
|
|
if (put_dbf_record(dbh, dbh->db_records, cp) < 0) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to put record at %ld", dbh->db_records);
|
1999-04-19 21:56:50 +08:00
|
|
|
efree(cp);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
put_dbf_info(dbh);
|
|
|
|
efree(cp);
|
|
|
|
|
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
1999-06-28 05:15:12 +08:00
|
|
|
/* {{{ proto bool dbase_replace_record(int identifier, array data, int recnum)
|
|
|
|
Replaces a record to the database */
|
1999-12-18 05:34:28 +08:00
|
|
|
PHP_FUNCTION(dbase_replace_record)
|
|
|
|
{
|
1999-06-28 05:15:12 +08:00
|
|
|
pval *dbh_id, *fields, *field, *recnum;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
|
|
|
|
int num_fields;
|
|
|
|
dbfield_t *dbf, *cur_f;
|
|
|
|
char *cp, *t_cp;
|
|
|
|
int i;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 3 || getParameters(ht,3,&dbh_id,&fields,&recnum)==FAILURE) {
|
1999-06-28 05:15:12 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
|
|
|
convert_to_long(recnum);
|
|
|
|
if (fields->type != IS_ARRAY) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Expected array as second parameter");
|
1999-06-28 05:15:12 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-06-28 05:15:12 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-06-28 05:15:12 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-08-03 03:17:14 +08:00
|
|
|
num_fields = zend_hash_num_elements(fields->value.ht);
|
1999-06-28 05:15:12 +08:00
|
|
|
|
|
|
|
if (num_fields != dbh->db_nfields) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Wrong number of fields specified");
|
1999-06-28 05:15:12 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
cp = t_cp = (char *)emalloc(dbh->db_rlen + 1);
|
|
|
|
if (!cp) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to allocate memory");
|
1999-06-28 05:15:12 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
*t_cp++ = VALID_RECORD;
|
|
|
|
|
|
|
|
dbf = dbh->db_fields;
|
|
|
|
for (i = 0, cur_f = dbf; cur_f < &dbf[num_fields]; i++, cur_f++) {
|
1999-08-03 03:17:14 +08:00
|
|
|
if (zend_hash_index_find(fields->value.ht, i, (void **)&field) == FAILURE) {
|
|
|
|
php_error(E_WARNING, "unexpected error");
|
1999-06-28 05:15:12 +08:00
|
|
|
efree(cp);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
convert_to_string(field);
|
|
|
|
sprintf(t_cp, cur_f->db_format, field->value.str.val);
|
|
|
|
t_cp += cur_f->db_flen;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (put_dbf_record(dbh, recnum->value.lval, cp) < 0) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to put record at %ld", dbh->db_records);
|
1999-06-28 05:15:12 +08:00
|
|
|
efree(cp);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
put_dbf_info(dbh);
|
|
|
|
efree(cp);
|
|
|
|
|
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
1999-04-19 21:56:50 +08:00
|
|
|
/* {{{ proto bool dbase_delete_record(int identifier, int record)
|
|
|
|
Marks a record to be deleted */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_delete_record) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id, *record;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&dbh_id,&record)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
|
|
|
convert_to_long(record);
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (del_dbf_record(dbh, record->value.lval) < 0) {
|
|
|
|
if (record->value.lval > dbh->db_records) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "record %d out of bounds", record->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
} else {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to delete record %d", record->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
}
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
put_dbf_info(dbh);
|
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto array dbase_get_record(int identifier, int record)
|
|
|
|
Returns an array representing a record from the database */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_get_record) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id, *record;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
dbfield_t *dbf, *cur_f;
|
|
|
|
char *data, *fnp, *str_value;
|
1999-06-28 05:23:17 +08:00
|
|
|
size_t cursize = 0;
|
1999-04-19 21:56:50 +08:00
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&dbh_id,&record)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
|
|
|
convert_to_long(record);
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((data = get_dbf_record(dbh, record->value.lval)) == NULL) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Tried to read bad record %d", record->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbf = dbh->db_fields;
|
|
|
|
|
|
|
|
if (array_init(return_value) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-06-28 05:23:17 +08:00
|
|
|
fnp = NULL;
|
1999-04-19 21:56:50 +08:00
|
|
|
for (cur_f = dbf; cur_f < &dbf[dbh->db_nfields]; cur_f++) {
|
|
|
|
/* get the value */
|
|
|
|
str_value = (char *)emalloc(cur_f->db_flen + 1);
|
1999-06-28 05:23:17 +08:00
|
|
|
|
|
|
|
if(cursize <= cur_f->db_flen) {
|
|
|
|
cursize = cur_f->db_flen + 1;
|
|
|
|
fnp = erealloc(fnp, cursize);
|
|
|
|
}
|
|
|
|
snprintf(str_value, cursize, cur_f->db_format, get_field_val(data, cur_f, fnp));
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
/* now convert it to the right php internal type */
|
|
|
|
switch (cur_f->db_type) {
|
|
|
|
case 'C':
|
|
|
|
case 'D':
|
|
|
|
add_next_index_string(return_value,str_value,1);
|
|
|
|
break;
|
|
|
|
case 'N': /* FALLS THROUGH */
|
|
|
|
case 'L': /* FALLS THROUGH */
|
|
|
|
if (cur_f->db_fdc == 0) {
|
|
|
|
add_next_index_long(return_value, strtol(str_value, NULL, 10));
|
|
|
|
} else {
|
|
|
|
add_next_index_double(return_value, atof(str_value));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'M':
|
|
|
|
/* this is a memo field. don't know how to deal with
|
|
|
|
this yet */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* should deal with this in some way */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
efree(str_value);
|
|
|
|
}
|
|
|
|
efree(fnp);
|
|
|
|
|
|
|
|
/* mark whether this record was deleted */
|
|
|
|
if (data[0] == '*') {
|
|
|
|
add_assoc_long(return_value,"deleted",1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
add_assoc_long(return_value,"deleted",0);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* From Martin Kuba <makub@aida.inet.cz> */
|
|
|
|
/* {{{ proto array dbase_get_record_with_names(int identifier, int record)
|
|
|
|
Returns an associative array representing a record from the database */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_get_record_with_names) {
|
1999-04-19 21:56:50 +08:00
|
|
|
pval *dbh_id, *record;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
int dbh_type;
|
|
|
|
dbfield_t *dbf, *cur_f;
|
|
|
|
char *data, *fnp, *str_value;
|
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&dbh_id,&record)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long(dbh_id);
|
|
|
|
convert_to_long(record);
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
dbh = zend_list_find(dbh_id->value.lval, &dbh_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
if (!dbh || dbh_type != DBase_GLOBAL(le_dbhead)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to find database for identifier %d", dbh_id->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((data = get_dbf_record(dbh, record->value.lval)) == NULL) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Tried to read bad record %d", record->value.lval);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbf = dbh->db_fields;
|
|
|
|
|
|
|
|
if (array_init(return_value) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
fnp = (char *)emalloc(dbh->db_rlen);
|
|
|
|
for (cur_f = dbf; cur_f < &dbf[dbh->db_nfields]; cur_f++) {
|
|
|
|
/* get the value */
|
|
|
|
str_value = (char *)emalloc(cur_f->db_flen + 1);
|
|
|
|
sprintf(str_value, cur_f->db_format, get_field_val(data, cur_f, fnp));
|
|
|
|
|
|
|
|
/* now convert it to the right php internal type */
|
|
|
|
switch (cur_f->db_type) {
|
|
|
|
case 'C':
|
|
|
|
case 'D':
|
|
|
|
add_assoc_string(return_value,cur_f->db_fname,str_value,1);
|
|
|
|
break;
|
|
|
|
case 'N': /* FALLS THROUGH */
|
|
|
|
case 'L': /* FALLS THROUGH */
|
|
|
|
if (cur_f->db_fdc == 0) {
|
|
|
|
add_assoc_long(return_value,cur_f->db_fname,strtol(str_value, NULL, 10));
|
|
|
|
} else {
|
|
|
|
add_assoc_double(return_value,cur_f->db_fname,atof(str_value));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'M':
|
|
|
|
/* this is a memo field. don't know how to deal with this yet */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* should deal with this in some way */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
efree(str_value);
|
|
|
|
}
|
|
|
|
efree(fnp);
|
|
|
|
|
|
|
|
/* mark whether this record was deleted */
|
|
|
|
if (data[0] == '*') {
|
|
|
|
add_assoc_long(return_value,"deleted",1);
|
|
|
|
} else {
|
|
|
|
add_assoc_long(return_value,"deleted",0);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto bool dbase_create(string filename, array fields)
|
|
|
|
Creates a new dBase-format database file */
|
1999-05-21 18:06:25 +08:00
|
|
|
PHP_FUNCTION(dbase_create) {
|
2000-07-20 10:48:44 +08:00
|
|
|
pval *filename, *fields, **field, **value;
|
1999-04-19 21:56:50 +08:00
|
|
|
int fd;
|
|
|
|
dbhead_t *dbh;
|
|
|
|
|
|
|
|
int num_fields;
|
|
|
|
dbfield_t *dbf, *cur_f;
|
|
|
|
int i, rlen, handle;
|
1999-12-12 18:51:44 +08:00
|
|
|
PLS_FETCH();
|
1999-04-19 21:56:50 +08:00
|
|
|
DBase_TLS_VARS;
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
if (ZEND_NUM_ARGS() != 2 || getParameters(ht,2,&filename,&fields)==FAILURE) {
|
1999-04-19 21:56:50 +08:00
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_string(filename);
|
|
|
|
|
|
|
|
if (fields->type != IS_ARRAY) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Expected array as second parameter");
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2000-11-03 07:08:07 +08:00
|
|
|
if (PG(safe_mode) && (!php_checkuid(Z_STRVAL_P(filename), NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2000-05-01 03:01:17 +08:00
|
|
|
if (php_check_open_basedir(Z_STRVAL_P(filename))) {
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-04-30 20:45:02 +08:00
|
|
|
if ((fd = VCWD_OPEN((Z_STRVAL_P(filename), O_BINARY|O_RDWR|O_CREAT, 0644))) < 0) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to create database (%d): %s", errno, strerror(errno));
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
1999-08-03 03:17:14 +08:00
|
|
|
num_fields = zend_hash_num_elements(fields->value.ht);
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
/* have to use regular malloc() because this gets free()d by
|
|
|
|
code in the dbase library */
|
|
|
|
dbh = (dbhead_t *)malloc(sizeof(dbhead_t));
|
|
|
|
dbf = (dbfield_t *)malloc(sizeof(dbfield_t) * num_fields);
|
|
|
|
if (!dbh || !dbf) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "Unable to allocate memory for header info");
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* initialize the header structure */
|
|
|
|
dbh->db_fields = dbf;
|
|
|
|
dbh->db_fd = fd;
|
|
|
|
dbh->db_dbt = DBH_TYPE_NORMAL;
|
|
|
|
strcpy(dbh->db_date, "19930818");
|
|
|
|
dbh->db_records = 0;
|
|
|
|
dbh->db_nfields = num_fields;
|
|
|
|
dbh->db_hlen = sizeof(struct dbf_dhead) + 2 + num_fields * sizeof(struct dbf_dfield);
|
|
|
|
|
|
|
|
rlen = 1;
|
2000-07-01 06:44:20 +08:00
|
|
|
/**
|
|
|
|
* Patch by greg@darkphoton.com
|
|
|
|
**/
|
|
|
|
/* make sure that the db_format entries for all fields are set to NULL to ensure we
|
|
|
|
don't seg fault if there's an error and we need to call free_dbf_head() before all
|
|
|
|
fields have been defined. */
|
|
|
|
for (i = 0, cur_f = dbf; i < num_fields; i++, cur_f++) {
|
|
|
|
cur_f->db_format = NULL;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* end patch
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1999-04-19 21:56:50 +08:00
|
|
|
for (i = 0, cur_f = dbf; i < num_fields; i++, cur_f++) {
|
|
|
|
/* look up the first field */
|
2000-07-20 10:48:44 +08:00
|
|
|
if (zend_hash_index_find(fields->value.ht, i, (void **)&field) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unable to find field %d", i);
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2000-07-20 10:48:44 +08:00
|
|
|
if (Z_TYPE_PP (field) != IS_ARRAY) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "second parameter must be array of arrays");
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* field name */
|
2000-07-20 10:48:44 +08:00
|
|
|
if (zend_hash_index_find(Z_ARRVAL_PP(field), 0, (void **)&value) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "expected field name as first element of list in field %d", i);
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-01 05:21:17 +08:00
|
|
|
convert_to_string_ex(value);
|
|
|
|
if ((*value)->value.str.len > 10 || (*value)->value.str.len == 0) {
|
|
|
|
php_error(E_WARNING, "invalid field name '%s' (must be non-empty and less than or equal to 10 characters)", (*value)->value.str.val);
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-01 05:21:17 +08:00
|
|
|
copy_crimp(cur_f->db_fname, (*value)->value.str.val, (*value)->value.str.len);
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
/* field type */
|
2000-07-20 10:48:44 +08:00
|
|
|
if (zend_hash_index_find(Z_ARRVAL_PP (field), 1,(void **)&value) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "expected field type as sececond element of list in field %d", i);
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-01 05:21:17 +08:00
|
|
|
convert_to_string_ex(value);
|
|
|
|
cur_f->db_type = toupper(*(*value)->value.str.val);
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
cur_f->db_fdc = 0;
|
|
|
|
|
|
|
|
/* verify the field length */
|
|
|
|
switch (cur_f->db_type) {
|
|
|
|
case 'L':
|
|
|
|
cur_f->db_flen = 1;
|
|
|
|
break;
|
|
|
|
case 'M':
|
|
|
|
cur_f->db_flen = 9;
|
|
|
|
dbh->db_dbt = DBH_TYPE_MEMO;
|
|
|
|
/* should create the memo file here, probably */
|
|
|
|
break;
|
|
|
|
case 'D':
|
|
|
|
cur_f->db_flen = 8;
|
|
|
|
break;
|
|
|
|
case 'N':
|
|
|
|
case 'C':
|
|
|
|
/* field length */
|
2000-07-20 10:48:44 +08:00
|
|
|
if (zend_hash_index_find(Z_ARRVAL_PP (field), 2,(void **)&value) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "expected field length as third element of list in field %d", i);
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-01 05:21:17 +08:00
|
|
|
convert_to_long_ex(value);
|
|
|
|
cur_f->db_flen = (*value)->value.lval;
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
if (cur_f->db_type == 'N') {
|
2000-07-20 10:48:44 +08:00
|
|
|
if (zend_hash_index_find(Z_ARRVAL_PP (field), 3, (void **)&value) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "expected field precision as fourth element of list in field %d", i);
|
1999-04-19 21:56:50 +08:00
|
|
|
free_dbf_head(dbh);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
2000-07-01 05:21:17 +08:00
|
|
|
convert_to_long_ex(value);
|
|
|
|
cur_f->db_fdc = (*value)->value.lval;
|
1999-04-19 21:56:50 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
1999-08-03 03:17:14 +08:00
|
|
|
php_error(E_WARNING, "unknown field type '%c'", cur_f->db_type);
|
1999-04-19 21:56:50 +08:00
|
|
|
}
|
|
|
|
cur_f->db_foffset = rlen;
|
|
|
|
rlen += cur_f->db_flen;
|
|
|
|
|
|
|
|
cur_f->db_format = get_dbf_f_fmt(cur_f);
|
|
|
|
}
|
|
|
|
|
|
|
|
dbh->db_rlen = rlen;
|
|
|
|
put_dbf_info(dbh);
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
handle = zend_list_insert(dbh, DBase_GLOBAL(le_dbhead));
|
1999-04-19 21:56:50 +08:00
|
|
|
RETURN_LONG(handle);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
function_entry dbase_functions[] = {
|
1999-07-28 01:17:05 +08:00
|
|
|
PHP_FE(dbase_open, NULL)
|
|
|
|
PHP_FE(dbase_create, NULL)
|
|
|
|
PHP_FE(dbase_close, NULL)
|
|
|
|
PHP_FE(dbase_numrecords, NULL)
|
|
|
|
PHP_FE(dbase_numfields, NULL)
|
|
|
|
PHP_FE(dbase_add_record, NULL)
|
|
|
|
PHP_FE(dbase_replace_record, NULL)
|
|
|
|
PHP_FE(dbase_get_record, NULL)
|
|
|
|
PHP_FE(dbase_get_record_with_names, NULL)
|
|
|
|
PHP_FE(dbase_delete_record, NULL)
|
|
|
|
PHP_FE(dbase_pack, NULL)
|
1999-04-19 21:56:50 +08:00
|
|
|
{NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
|
1999-12-18 04:55:31 +08:00
|
|
|
zend_module_entry dbase_module_entry = {
|
2000-03-07 02:44:01 +08:00
|
|
|
"dbase", dbase_functions, PHP_MINIT(dbase), PHP_MSHUTDOWN(dbase), NULL, NULL, NULL, STANDARD_MODULE_PROPERTIES
|
1999-04-19 21:56:50 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2000-05-23 17:33:51 +08:00
|
|
|
#ifdef COMPILE_DL_DBASE
|
2000-05-02 08:30:36 +08:00
|
|
|
ZEND_GET_MODULE(dbase)
|
1999-04-19 21:56:50 +08:00
|
|
|
|
|
|
|
#if (WIN32|WINNT) && defined(THREAD_SAFE)
|
|
|
|
|
|
|
|
/*NOTE: You should have an odbc.def file where you
|
|
|
|
export DllMain*/
|
|
|
|
BOOL WINAPI DllMain(HANDLE hModule,
|
|
|
|
DWORD ul_reason_for_call,
|
|
|
|
LPVOID lpReserved)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* tab-width: 4
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* End:
|
|
|
|
*/
|