#define NS 10
/*
- * _php3_reg_eprint - convert error number to name
+ * php_reg_eprint - convert error number to name
*/
-static void _php3_reg_eprint(int err, regex_t *re) {
+static void php_reg_eprint(int err, regex_t *re) {
char *buf = NULL, *message = NULL;
size_t len;
size_t buf_len;
STR_FREE(message);
}
-static void _php3_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
+static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
{
pval **regex, /* Regular expression */
**findin, /* String to apply expression to */
}
if (err) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
RETURN_FALSE;
}
/* actually execute the regular expression */
err = regexec(&re, string, (size_t) NS, subs, 0);
if (err && err != REG_NOMATCH) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
regfree(&re);
RETURN_FALSE;
}
buf = emalloc(string_len);
if (!buf) {
- php_error(E_WARNING, "Unable to allocate memory in _php3_ereg");
+ php_error(E_WARNING, "Unable to allocate memory in php_ereg");
RETURN_FALSE;
}
Regular expression match */
PHP_FUNCTION(ereg)
{
- _php3_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
Case-insensitive regular expression match */
PHP_FUNCTION(eregi)
{
- _php3_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
/* this is the meat and potatoes of regex replacement! */
-char *_php3_regreplace(const char *pattern, const char *replace, const char *string, int icase, int extended)
+char *php_reg_replace(const char *pattern, const char *replace, const char *string, int icase, int extended)
{
regex_t re;
regmatch_t subs[NS];
copts |= REG_EXTENDED;
err = regcomp(&re, pattern, copts);
if (err) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
return ((char *) -1);
}
buf_len = 2 * string_len + 1;
buf = emalloc(buf_len * sizeof(char));
if (!buf) {
- php_error(E_WARNING, "Unable to allocate memory in _php3_regreplace");
+ php_error(E_WARNING, "Unable to allocate memory in php_reg_replace");
regfree(&re);
return ((char *) -1);
}
err = regexec(&re, &string[pos], (size_t) NS, subs, (pos ? REG_NOTBOL : 0));
if (err && err != REG_NOMATCH) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
regfree(&re);
return ((char *) -1);
}
return (buf);
}
-static void _php3_eregreplace(INTERNAL_FUNCTION_PARAMETERS, int icase)
+static void php_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase)
{
pval **arg_pattern,
**arg_replace,
string = empty_string;
/* do the actual work */
- ret = _php3_regreplace(pattern, replace, string, icase, 1);
+ ret = php_reg_replace(pattern, replace, string, icase, 1);
if (ret == (char *) -1) {
RETVAL_FALSE;
} else {
Replace regular expression */
PHP_FUNCTION(ereg_replace)
{
- _php3_eregreplace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
Case insensitive replace regular expression */
PHP_FUNCTION(eregi_replace)
{
- _php3_eregreplace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
extern zend_module_entry regexp_module_entry;
#define regexp_module_ptr ®exp_module_entry
-char *_php3_regreplace(const char *pattern, const char *replace, const char *string, int icase, int extended);
+char *php_reg_replace(const char *pattern, const char *replace, const char *string, int icase, int extended);
PHP_FUNCTION(ereg);
PHP_FUNCTION(eregi);
len = strlen(PS(session_name)) + strlen(PS(id)) + sizeof(COOKIE_FMT);
if (PS(cookie_lifetime) > 0) {
- date_fmt = php3_std_date(time(NULL) + PS(cookie_lifetime));
+ date_fmt = php_std_date(time(NULL) + PS(cookie_lifetime));
len += sizeof(COOKIE_EXPIRES) + strlen(date_fmt);
}
PHP_FE(doubleval, NULL)
PHP_FE(strval, NULL)
PHP_FE(bin2hex, NULL)
- PHP_FE(toggle_short_open_tag, NULL)
PHP_FE(sleep, NULL)
PHP_FE(usleep, NULL)
PHP_FE(getmypid, NULL)
PHP_FE(getmyinode, NULL)
PHP_FE(getlastmod, NULL)
- /*getmyiid is here for forward compatibility with 3.1
- See pageinfo.c in 3.1 for more information*/
- /* {"getmyiid", php3_getmypid, NULL}, */
PHP_FE(base64_decode, NULL)
PHP_FE(base64_encode, NULL)
#if defined(HAVE_PUTENV)
-static int _php3_putenv_destructor(putenv_entry *pe)
+static int php_putenv_destructor(putenv_entry *pe)
{
if (pe->previous_value) {
putenv(pe->previous_value);
BG(page_inode) = -1;
BG(page_mtime) = -1;
#ifdef HAVE_PUTENV
- if (zend_hash_init(&BG(putenv_ht), 1, NULL, (int (*)(void *)) _php3_putenv_destructor, 0) == FAILURE) {
+ if (zend_hash_init(&BG(putenv_ht), 1, NULL, (int (*)(void *)) php_putenv_destructor, 0) == FAILURE) {
return FAILURE;
}
#endif
#endif
-
-PHP_FUNCTION(toggle_short_open_tag)
-{
- /* has to be implemented within Zend */
-#if 0
- pval **value;
- int ret;
-
- ret = php3_ini.short_open_tag;
-
- if (ARG_COUNT(ht)!=1 || getParametersEx(1,&value) == FAILURE) {
- WRONG_PARAM_COUNT;
- }
- convert_to_long_ex(value);
- php3_ini.short_open_tag = (*value)->value.lval;
- RETURN_LONG(ret);
-#endif
-}
-
/*******************
* Basic Functions *
*******************/
convert_to_string(return_value);
}
-#ifdef __cplusplus
-void php3_flush(HashTable *)
-#else
PHP_FUNCTION(flush)
-#endif
{
#if APACHE
SLS_FETCH();
case 1: /*send an email*/
{
#if HAVE_SENDMAIL
- if (!_php3_mail(opt,"PHP error_log message",message,headers)){
+ if (!php_mail(opt,"PHP error_log message",message,headers)){
return FAILURE;
}
#else
static unsigned char itoa64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-static void php3i_to64(char *s, long v, int n) {
+static void php_to64(char *s, long v, int n) {
while (--n >= 0) {
*s++ = itoa64[v&0x3f];
v >>= 6;
#endif
#if PHP3_STD_DES_CRYPT
- php3i_to64(&salt[0], PHP3_CRYPT_RAND, 2);
+ php_to64(&salt[0], PHP3_CRYPT_RAND, 2);
salt[2] = '\0';
#else
#if PHP3_MD5_CRYPT
strcpy(salt, "$1$");
- php3i_to64(&salt[3], PHP3_CRYPT_RAND, 4);
- php3i_to64(&salt[7], PHP3_CRYPT_RAND, 4);
+ php_to64(&salt[3], PHP3_CRYPT_RAND, 4);
+ php_to64(&salt[7], PHP3_CRYPT_RAND, 4);
strcpy(&salt[11], "$");
#endif
#endif
* d - x-cp866
* m - x-mac-cyrillic
*****************************************************************************/
-static char * _php3_convert_cyr_string(unsigned char *str, char from, char to)
+static char * php_convert_cyr_string(unsigned char *str, char from, char to)
{
const unsigned char *from_table, *to_table;
unsigned char tmp;
str = (unsigned char*) str_arg->value.str.val;
- _php3_convert_cyr_string(str, fr_cs->value.str.val[0], to_cs->value.str.val[0]);
+ php_convert_cyr_string(str, fr_cs->value.str.val[0], to_cs->value.str.val[0]);
RETVAL_STRING((char *)str, 1)
}
/* }}} */
return_value->type = IS_LONG;
}
-void _php3_mktime(INTERNAL_FUNCTION_PARAMETERS, int gm)
+void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gm)
{
pval *arguments[7];
struct tm *ta, tmbuf;
PHP_FUNCTION(mktime)
{
- _php3_mktime(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_mktime(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
PHP_FUNCTION(gmmktime)
{
- _php3_mktime(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_mktime(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
static void
-_php3_date(INTERNAL_FUNCTION_PARAMETERS, int gm)
+php_date(INTERNAL_FUNCTION_PARAMETERS, int gm)
{
pval *format, *timestamp;
time_t the_time;
PHP_FUNCTION(date)
{
- _php3_date(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_date(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
PHP_FUNCTION(gmdate)
{
- _php3_date(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_date(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
PHP_FUNCTION(getdate)
}
/* Return date string in standard format for http headers */
-char *php3_std_date(time_t t)
+char *php_std_date(time_t t)
{
struct tm *tm1, tmbuf;
char *str;
#endif
PHP_FUNCTION(strtotime);
-extern char *php3_std_date(time_t t);
-void _php3_mktime(INTERNAL_FUNCTION_PARAMETERS, int gm);
+extern char *php_std_date(time_t t);
+void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gm);
#endif /* _DATETIME_H */
};
-zend_module_entry php3_dir_module_entry = {
+zend_module_entry php_dir_module_entry = {
"PHP_dir", php_dir_functions, PHP_MINIT(dir), NULL, NULL, NULL, NULL, STANDARD_MODULE_PROPERTIES
};
#include "dns.h"
-char *_php3_gethostbyaddr(char *ip);
-char *_php3_gethostbyname(char *name);
+char *php_gethostbyaddr(char *ip);
+char *php_gethostbyname(char *name);
/* {{{ proto string gethostbyaddr(string ip_address)
Get the Internet host name corresponding to a given IP address */
}
convert_to_string_ex(arg);
- return_value->value.str.val = _php3_gethostbyaddr((*arg)->value.str.val);
+ return_value->value.str.val = php_gethostbyaddr((*arg)->value.str.val);
return_value->value.str.len = strlen(return_value->value.str.val);
return_value->type = IS_STRING;
}
/* }}} */
-char *_php3_gethostbyaddr(char *ip)
+char *php_gethostbyaddr(char *ip)
{
unsigned long addr;
struct hostent *hp;
}
convert_to_string_ex(arg);
- return_value->value.str.val = _php3_gethostbyname((*arg)->value.str.val);
+ return_value->value.str.val = php_gethostbyname((*arg)->value.str.val);
return_value->value.str.len = strlen(return_value->value.str.val);
return_value->type = IS_STRING;
}
}
/* }}} */
-char *_php3_gethostbyname(char *name)
+char *php_gethostbyname(char *name)
{
struct hostent *hp;
struct in_addr in;
*c = ' ';
strncat(d, c, overflow_limit);
}
- tmp = _php3_escapeshellcmd(d);
+ tmp = php_escape_shell_cmd(d);
efree(d);
d = tmp;
#if WIN32|WINNT
}
/* }}} */
-static int php3_ind(char *s, char c)
+static int php_get_index(char *s, char c)
{
register int x;
*NOT* safe for binary strings
*/
-char * _php3_escapeshellcmd(char *str) {
+char * php_escape_shell_cmd(char *str) {
register int x, y, l;
char *cmd;
cmd = emalloc(2 * l + 1);
strcpy(cmd, str);
for (x = 0; cmd[x]; x++) {
- if (php3_ind("&;`'\"|*?~<>^()[]{}$\\\x0A\xFF", cmd[x]) != -1) {
+ if (php_get_index("&;`'\"|*?~<>^()[]{}$\\\x0A\xFF", cmd[x]) != -1) {
for (y = l + 1; y > x; y--)
cmd[y] = cmd[y - 1];
l++; /* length has been increased */
convert_to_string(arg1);
if (arg1->value.str.len) {
- cmd = _php3_escapeshellcmd(arg1->value.str.val);
+ cmd = php_escape_shell_cmd(arg1->value.str.val);
RETVAL_STRING(cmd, 1);
efree(cmd);
}
PHP_FUNCTION(passthru);
PHP_FUNCTION(shell_exec);
-char *_php3_escapeshellcmd(char *);
+char *php_escape_shell_cmd(char *);
#endif /* _EXEC_H */
/* $Id$ */
-/* Synced with php3 revision 1.218 1999-06-16 [ssb] */
+/* Synced with php 3.0 revision 1.218 1999-06-16 [ssb] */
/* {{{ includes */
/*
* We need a better way of returning error messages from
- * php3_fopen__wrapper().
+ * php_fopen_wrapper().
*/
fp = php_fopen_wrapper((*arg1)->value.str.val, p, use_include_path|ENFORCE_SAFE_MODE, &issock, &socketd, NULL);
if (!fp && !socketd) {
/* {{{ proto int set_socket_blocking(int socket descriptor, int mode)
Set blocking/non-blocking mode on a socket */
-PHPAPI int _php3_set_sock_blocking(int socketd, int block)
+PHPAPI int php_set_sock_blocking(int socketd, int block)
{
int ret = SUCCESS;
int flags;
socketd = *(int*)what;
- if (_php3_set_sock_blocking(socketd, block) == FAILURE)
+ if (php_set_sock_blocking(socketd, block) == FAILURE)
RETURN_FALSE;
php_sockset_blocking(socketd, block == 0 ? 0 : 1);
char *temp, *tptr, *bptr;
char delimiter = ','; /* allow this to be set as parameter */
- /* first section exactly as php3_fgetss */
+ /* first section exactly as php_fgetss */
pval **fd, **bytes, **p_delim;
int len, type;
/* $Id$ */
-/* Synced with php3 revision 1.30 1999-06-16 [ssb] */
+/* Synced with php 3.0 revision 1.30 1999-06-16 [ssb] */
#ifndef _FILE_H
#define _FILE_H
PHP_FUNCTION(fd_isset);
PHP_FUNCTION(select);
-PHPAPI int _php3_set_sock_blocking(int socketd, int block);
+PHPAPI int php_set_sock_blocking(int socketd, int block);
PHPAPI int php_file_le_fopen(void);
PHPAPI int php_file_le_socket(void);
PHPAPI int php_file_le_uploads(void);
}
-static void _php3_stat(const char *filename, int type, pval *return_value)
+static void php_stat(const char *filename, int type, pval *return_value)
{
struct stat *stat_sb;
BLS_FETCH();
WRONG_PARAM_COUNT; \
} \
convert_to_string(filename); \
- _php3_stat(filename->value.str.val, funcnum, return_value); \
+ php_stat(filename->value.str.val, funcnum, return_value); \
}
FileFunction(PHP_FN(fileperms),0)
FileFunction(PHP_FN(lstat),16)
FileFunction(PHP_FN(stat),17)
-function_entry php3_filestat_functions[] = {
+function_entry php_filestat_functions[] = {
PHP_FE(fileatime, NULL)
PHP_FE(filectime, NULL)
PHP_FE(filegroup, NULL)
};
-zend_module_entry php3_filestat_module_entry = {
- "PHP_filestat", php3_filestat_functions, NULL, NULL, PHP_RINIT(filestat),
+zend_module_entry php_filestat_module_entry = {
+ "PHP_filestat", php_filestat_functions, NULL, NULL, PHP_RINIT(filestat),
PHP_RSHUTDOWN(filestat), NULL, STANDARD_MODULE_PROPERTIES
};
*/
/*
- * _php3_cvt converts to decimal
+ * php_convert_to_decimal converts to decimal
* the number of digits is specified by ndigit
* decpt is set to the position of the decimal point
* sign is set to 0 for positive, 1 for negative
*/
-static char *
-_php3_cvt(double arg, int ndigits, int *decpt, int *sign, int eflag)
+static char *php_convert_to_decimal(double arg, int ndigits, int *decpt, int *sign, int eflag)
{
register int r2;
double fi, fj;
} else if (precision > MAX_FLOAT_PRECISION) {
precision = MAX_FLOAT_PRECISION;
}
- cvt = _php3_cvt(number, precision, &decpt, &sign, (fmt == 'e'));
+ cvt = php_convert_to_decimal(number, precision, &decpt, &sign, (fmt == 'e'));
if (sign) {
numbuf[i++] = '-';
/* $Id$ */
-/* Synced with php3 revision 1.121 1999-06-18 [ssb] */
-/* Synced with php3 revision 1.133 1999-07-21 [sas] */
+/* Synced with php 3.0 revision 1.121 1999-06-18 [ssb] */
+/* Synced with php 3.0 revision 1.133 1999-07-21 [sas] */
#include "php.h"
#include "php_globals.h"
{NULL, NULL, NULL}
};
-struct php3i_sockbuf {
+struct php_sockbuf {
int socket;
unsigned char *readbuf;
size_t readbuflen;
size_t readpos;
size_t writepos;
- struct php3i_sockbuf *next;
- struct php3i_sockbuf *prev;
+ struct php_sockbuf *next;
+ struct php_sockbuf *prev;
char eof;
char persistent;
char is_blocked;
size_t chunk_size;
};
-typedef struct php3i_sockbuf php3i_sockbuf;
+typedef struct php_sockbuf php_sockbuf;
zend_module_entry fsock_module_entry = {
"Socket functions",
return 0;
}
/* }}} */
-/* {{{ _php3_is_persistent_sock */
+/* {{{ php_is_persistent_sock */
-int _php3_is_persistent_sock(int sock)
+int php_is_persistent_sock(int sock)
{
char *key;
FLS_FETCH();
#endif
}
/* }}} */
-/* {{{ _php3_fsockopen() */
+/* {{{ php_fsockopen() */
/*
This function takes an optional third argument which should be
passed by reference. The error code from the connect call is written
to this variable.
*/
-static void _php3_fsockopen(INTERNAL_FUNCTION_PARAMETERS, int persistent) {
+static void php_fsockopen(INTERNAL_FUNCTION_PARAMETERS, int persistent) {
pval *args[5];
int *sock=emalloc(sizeof(int));
int *sockp;
Open Internet or Unix domain socket connection */
PHP_FUNCTION(fsockopen)
{
- _php3_fsockopen(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_fsockopen(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
/* {{{ proto int pfsockopen(string hostname, int port [, int errno [, string errstr [, double timeout]]])
Open persistent Internet or Unix domain socket connection */
PHP_FUNCTION(pfsockopen)
{
- _php3_fsockopen(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_fsockopen(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
static void php_cleanup_sockbuf(int persistent FLS_DC)
{
- php3i_sockbuf *now, *next;
+ php_sockbuf *now, *next;
for(now = FG(phpsockbuf); now; now = next) {
next = now->next;
#define READPTR(sock) ((sock)->readbuf + (sock)->readpos)
#define WRITEPTR(sock) ((sock)->readbuf + (sock)->writepos)
#define SOCK_FIND(sock,socket) \
- php3i_sockbuf *sock; \
+ php_sockbuf *sock; \
FLS_FETCH(); \
sock = php_sockfind(socket FLS_CC); \
if(!sock) sock = php_sockcreate(socket FLS_CC)
-static php3i_sockbuf *php_sockfind(int socket FLS_DC)
+static php_sockbuf *php_sockfind(int socket FLS_DC)
{
- php3i_sockbuf *buf = NULL, *tmp;
+ php_sockbuf *buf = NULL, *tmp;
for(tmp = FG(phpsockbuf); tmp; tmp = tmp->next)
if(tmp->socket == socket) {
return buf;
}
-static php3i_sockbuf *php_sockcreate(int socket FLS_DC)
+static php_sockbuf *php_sockcreate(int socket FLS_DC)
{
- php3i_sockbuf *sock;
- int persistent = _php3_is_persistent_sock(socket);
+ php_sockbuf *sock;
+ int persistent = php_is_persistent_sock(socket);
sock = pecalloc(sizeof(*sock), 1, persistent);
sock->socket = socket;
int php_sockdestroy(int socket)
{
int ret = 0;
- php3i_sockbuf *sock;
+ php_sockbuf *sock;
FLS_FETCH();
sock = php_sockfind(socket FLS_CC);
int php_sock_close(int socket)
{
int ret = 0;
- php3i_sockbuf *sock;
+ php_sockbuf *sock;
FLS_FETCH();
sock = php_sockfind(socket FLS_CC);
#define MAX_CHUNKS_PER_READ 10
-static void php_sockwait_for_data(php3i_sockbuf *sock)
+static void php_sockwait_for_data(php_sockbuf *sock)
{
fd_set fdr, tfdr;
}
}
-static size_t php_sockread_internal(php3i_sockbuf *sock)
+static size_t php_sockread_internal(php_sockbuf *sock)
{
char buf[CHUNK_SIZE];
int nr_bytes;
return nr_read;
}
-static void php_sockread_total(php3i_sockbuf *sock, size_t maxread)
+static void php_sockread_total(php_sockbuf *sock, size_t maxread)
{
while(!sock->eof && TOREAD(sock) < maxread) {
php_sockread_internal(sock);
}
}
-static size_t php_sockread(php3i_sockbuf *sock)
+static size_t php_sockread(php_sockbuf *sock)
{
size_t nr_bytes;
size_t nr_read = 0;
return 1;
}
/* }}} */
- /* {{{ php3_minit_fsock */
static void fsock_globals_ctor(FLS_D)
{
#endif
return SUCCESS;
}
-/* }}} */
- /* {{{ php3_mshutdown_fsock */
PHP_MSHUTDOWN_FUNCTION(fsock)
{
#endif
return SUCCESS;
}
-/* }}} */
- /* {{{ php3_rshutdown_fsock() */
PHP_RSHUTDOWN_FUNCTION(fsock)
{
return SUCCESS;
}
-/* }}} */
-
-/* }}} */
-
/*
* Local variables:
* tab-width: 4
*/
/* $Id$ */
-/* Synced with php3 revision 1.24 1999-06-18 [ssb] */
+/* Synced with php 3.0 revision 1.24 1999-06-18 [ssb] */
#ifndef _FSOCK_H
#define _FSOCK_H
size_t php_sock_fread(char *buf, size_t maxlen, int socket);
int php_sock_feof(int socket);
int php_sock_fgetc(int socket);
-int _php3_is_persistent_sock(int);
+int php_is_persistent_sock(int);
int php_sockset_blocking(int socket, int mode);
int php_sockdestroy(int socket);
int php_sock_close(int socket);
typedef struct {
HashTable ht_fsock_keys;
HashTable ht_fsock_socks;
- struct php3i_sockbuf *phpsockbuf;
+ struct php_sockbuf *phpsockbuf;
size_t def_chunk_size;
} php_fsock_globals;
been defined with C compiler flags.
*/
#ifndef PROTOTYPES
-#define PROTOTYPES 1 /* php3 has prototypes everywhere */
+#define PROTOTYPES 1 /* PHP has prototypes everywhere */
#endif
/* _POINTER defines a generic pointer type */
/* need to figure out some nice way to get rid of these */
#ifndef THREAD_SAFE
-static int php3_HeaderPrinted = 0;
-static int php3_PrintHeader = 1;
+static int php_header_printed = 0;
+static int php_print_header = 1;
static CookieList *top = NULL;
static char *cont_type = NULL;
static int header_called = 0;
#endif
-void php3_PushCookieList(char *, char *, time_t, char *, char *, int);
-CookieList *php3_PopCookieList(void);
+void php_push_cookie_list(char *, char *, time_t, char *, char *, int);
+CookieList *php_pop_cookie_list(void);
PHP_RINIT_FUNCTION(head)
{
- php3_HeaderPrinted = 0;
+ php_header_printed = 0;
if (header_called == 0)
- php3_PrintHeader = 1;
+ php_print_header = 1;
top = NULL;
cont_type = NULL;
req = ((request_rec *) SG(server_context));
#endif
- if (php3_HeaderPrinted == 1) {
+ if (php_header_printed == 1) {
#if DEBUG
php_error(E_WARNING, "Cannot add more header information - the header was already sent "
"(header information may be added only before any output is generated from the script - "
if (PG(safe_mode) && (!strcasecmp(header_information, "WWW-authenticate"))) {
myuid = php_getuid();
sprintf(temp2, "realm=\"%ld ", myuid); /* SAFE */
- temp = _php3_regreplace("realm=\"", temp2, rr, 1, 0);
+ temp = php_reg_replace("realm=\"", temp2, rr, 1, 0);
if (!strcmp(temp, rr)) {
sprintf(temp2, "realm=%ld", myuid); /* SAFE */
- temp = _php3_regreplace("realm=", temp2, rr, 1, 0);
+ temp = php_reg_replace("realm=", temp2, rr, 1, 0);
if (!strcmp(temp, rr)) {
sprintf(temp2, " realm=%ld", myuid); /* SAFE */
- temp = _php3_regreplace("$", temp2, rr, 0, 0);
+ temp = php_reg_replace("$", temp2, rr, 0, 0);
}
}
table_set(req->headers_out, header_information, temp);
req->status = REDIRECT;
}
*r = ':';
- php3_HeaderPrinted = 2;
+ php_header_printed = 2;
}
if (!strncasecmp(header_information, "http/", 5)) {
if (strlen(header_information) > 9) {
sapi_rqst->header(sapi_rqst->scid,tempstr);
efree(tempstr);
}
-#elif FHTTPD
- php3_fhttpd_puts_header(header_information);
- php3_fhttpd_puts_header("\r\n");
#else
PUTS_H(header_information);
PUTS_H("\015\012");
sapi_rqst->header(sapi_rqst->scid,tempstr);
efree(tempstr);
}
-#elif FHTTPD
- php3_fhttpd_puts_header(header_information);
- php3_fhttpd_puts_header("\r\n");
#else
PUTS_H(header_information);
PUTS_H("\015\012");
PG(header_is_being_sent) = 0;
return 1;
}
- if ((php3_PrintHeader && !php3_HeaderPrinted) || (php3_PrintHeader && php3_HeaderPrinted == 2)) {
- cookie = php3_PopCookieList();
+ if ((php_print_header && !php_header_printed) || (php_print_header && php_header_printed == 2)) {
+ cookie = php_pop_cookie_list();
while (cookie) {
if (cookie->name)
len += strlen(cookie->name);
if (cookie->value) {
- cookievalue = _php3_urlencode(cookie->value, strlen (cookie->value));
+ cookievalue = php_url_encode(cookie->value, strlen (cookie->value));
len += strlen(cookievalue);
}
if (cookie->path)
sprintf(tempstr, "%s=deleted", cookie->name);
t = time(NULL) - 31536001;
strcat(tempstr, "; expires=");
- dt = php3_std_date(t);
+ dt = php_std_date(t);
strcat(tempstr, dt);
efree(dt);
} else {
cookievalue=NULL;
if (cookie->expires > 0) {
strcat(tempstr, "; expires=");
- dt = php3_std_date(cookie->expires);
+ dt = php_std_date(cookie->expires);
strcat(tempstr, dt);
efree(dt);
}
if (cookie->value) efree(cookie->value);
if (cookievalue) efree(cookievalue);
efree(cookie);
- cookie = php3_PopCookieList();
+ cookie = php_pop_cookie_list();
efree(tempstr);
}
- php3_HeaderPrinted = 1;
+ php_header_printed = 1;
header_called = 1;
send_http_header(((request_rec *) SG(server_context)));
if (((request_rec *) SG(server_context))->header_only) {
}
}
#else
- if (php3_PrintHeader && !php3_HeaderPrinted) {
+ if (php_print_header && !php_header_printed) {
if (!cont_type) {
#if USE_SAPI
sapi_rqst->header(sapi_rqst->scid,"Content-type: text/html\015\012\015\012");
-#elif FHTTPD
- php3_fhttpd_puts_header("Content-type: text/html\r\n");
#else
PUTS_H("Content-type: text/html\015\012\015\012");
#endif
sprintf(tempstr,"Content-type: %s\015\012\015\012",cont_type);
sapi_rqst->header(sapi_rqst->scid,tempstr);
efree(tempstr);
-#elif FHTTPD
- tempstr = emalloc(strlen(cont_type)
- + sizeof("Content-type:") + 2);
- if(tempstr) {
- strcpy(tempstr, "Content-type:");
- strcpy(tempstr + sizeof("Content-type:") - 1,
- cont_type);
- strcat(tempstr, "\r\n");
- php3_fhttpd_puts_header(tempstr);
- efree(tempstr);
- }
#else
PUTS_H("Content-type:");
PUTS_H(cont_type);
#else
fflush(stdout);
#endif
- php3_HeaderPrinted = 1;
+ php_header_printed = 1;
header_called = 1;
}
#endif
-void php3_PushCookieList(char *name, char *value, time_t expires, char *path, char *domain, int secure)
+void php_push_cookie_list(char *name, char *value, time_t expires, char *path, char *domain, int secure)
{
CookieList *new;
top = new;
}
-CookieList *php3_PopCookieList(void)
+CookieList *php_pop_cookie_list(void)
{
CookieList *ret;
return (ret);
}
-/* php3_setcookie(name,value,expires,path,domain,secure) */
+/* php_set_cookie(name,value,expires,path,domain,secure) */
PHP_FUNCTION(setcookie)
{
char *cookie;
if (arg_count < 1 || arg_count > 6 || getParametersArray(ht, arg_count, arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
- if (php3_HeaderPrinted == 1) {
- php_error(E_WARNING, "Oops, php3_SetCookie called after header has been sent\n");
+ if (php_header_printed == 1) {
+ php_error(E_WARNING, "Oops, php_set_cookie called after header has been sent\n");
return;
}
switch (arg_count) {
break;
}
#if 0
- php3_PushCookieList(name, value, expires, path, domain, secure);
+ php_push_cookie_list(name, value, expires, path, domain, secure);
#else
if (name) {
len += strlen(name);
sprintf(cookie, "Set-Cookie: %s=deleted", name);
strcat(cookie, "; expires=");
t = time(NULL) - 31536001;
- dt = php3_std_date(t);
+ dt = php_std_date(t);
strcat(cookie, dt);
efree(dt);
} else {
/* FIXME: XXX: this is not binary data safe */
- r = _php3_urlencode(value, strlen (value));
+ r = php_url_encode(value, strlen (value));
sprintf(cookie, "Set-Cookie: %s=%s", name, value ? r : "");
if (r) efree(r);
if (value) efree(value);
name=NULL;
if (expires > 0) {
strcat(cookie, "; expires=");
- dt = php3_std_date(expires);
+ dt = php_std_date(expires);
strcat(cookie, dt);
efree(dt);
}
int php_headers_unsent(void)
{
- if (php3_HeaderPrinted!=1 || !php3_PrintHeader) {
+ if (php_header_printed!=1 || !php_print_header) {
return 1;
} else {
return 0;
"uuml","yacute","thorn","yuml"
};
-static void _php3_htmlentities(INTERNAL_FUNCTION_PARAMETERS, int all)
+static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all)
{
pval **arg;
int i, len, maxlen;
Convert special characters to HTML entities */
PHP_FUNCTION(htmlspecialchars)
{
- _php3_htmlentities(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);
+ php_html_entities(INTERNAL_FUNCTION_PARAM_PASSTHRU,0);
}
/* }}} */
Convert all applicable characters to HTML entities */
PHP_FUNCTION(htmlentities)
{
- _php3_htmlentities(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);
+ php_html_entities(INTERNAL_FUNCTION_PARAM_PASSTHRU,1);
}
/* }}} */
#include "php_image.h"
/* file type markers */
-const char php3_sig_gif[3] =
+const char php_sig_gif[3] =
{'G', 'I', 'F'};
-const char php3_sig_jpg[3] =
+const char php_sig_jpg[3] =
{(char) 0xff, (char) 0xd8, (char) 0xff};
-const char php3_sig_png[8] =
+const char php_sig_png[8] =
{(char) 0x89, (char) 0x50, (char) 0x4e,
(char) 0x47, (char) 0x0d, (char) 0x0a,
(char) 0x1a, (char) 0x0a};
};
/* routine to handle GIF files. If only everything were that easy... ;} */
-static struct gfxinfo *php3_handle_gif (FILE *fp)
+static struct gfxinfo *php_handle_gif (FILE *fp)
{
struct gfxinfo *result = NULL;
unsigned char a[2];
return result;
}
-static unsigned long php3_read4(FILE *fp)
+static unsigned long php_read4(FILE *fp)
{
unsigned char a[ 4 ];
}
/* routine to handle PNG files. - even easier */
-static struct gfxinfo *php3_handle_png(FILE *fp)
+static struct gfxinfo *php_handle_png(FILE *fp)
{
struct gfxinfo *result = NULL;
unsigned long in_width, in_height;
result = (struct gfxinfo *) ecalloc(1,sizeof(struct gfxinfo));
fseek(fp, 16L, SEEK_SET);
- in_width = php3_read4(fp);
- in_height = php3_read4(fp);
+ in_width = php_read4(fp);
+ in_height = php_read4(fp);
result->width = (unsigned int) in_width;
result->height = (unsigned int) in_height;
return result;
#define M_APP14 0xee
#define M_APP15 0xef
-static unsigned short php3_read2(FILE *fp)
+static unsigned short php_read2(FILE *fp)
{
unsigned char a[ 2 ];
return (((unsigned short) a[ 0 ]) << 8) + ((unsigned short) a[ 1 ]);
}
-static unsigned int php3_next_marker(FILE *fp)
+static unsigned int php_next_marker(FILE *fp)
/* get next marker byte from file */
{
int c;
return (unsigned int) c;
}
-static void php3_skip_variable(FILE *fp)
+static void php_skip_variable(FILE *fp)
/* skip over a variable-length block; assumes proper length marker */
{
unsigned short length;
- length = php3_read2(fp);
+ length = php_read2(fp);
length -= 2; /* length includes itself */
fseek(fp, (long) length, SEEK_CUR); /* skip the header */
}
-static void php3_read_APP(FILE *fp,unsigned int marker,pval *info)
+static void php_read_APP(FILE *fp,unsigned int marker,pval *info)
{
unsigned short length;
unsigned char *buffer;
unsigned char markername[ 16 ];
- length = php3_read2(fp);
+ length = php_read2(fp);
length -= 2; /* length includes itself */
buffer = emalloc(length);
efree(buffer);
}
-static struct gfxinfo *php3_handle_jpeg(FILE *fp,pval *info)
+static struct gfxinfo *php_handle_jpeg(FILE *fp,pval *info)
/* main loop to parse JPEG structure */
{
struct gfxinfo *result = NULL;
return NULL;
for (;;) {
- marker = php3_next_marker(fp);
+ marker = php_next_marker(fp);
switch (marker) {
case M_SOF0:
case M_SOF1:
fseek(fp, 2, SEEK_CUR);
result->bits = fgetc(fp);
- result->height = php3_read2(fp);
- result->width = php3_read2(fp);
+ result->height = php_read2(fp);
+ result->width = php_read2(fp);
result->channels = fgetc(fp);
if (! info) /* if we don't want an extanded info -> return */
return result;
} else {
- php3_skip_variable(fp);
+ php_skip_variable(fp);
}
break;
case M_APP14:
case M_APP15:
if (info) {
- php3_read_APP(fp,marker,info); /* read all the app markes... */
+ php_read_APP(fp,marker,info); /* read all the app markes... */
} else {
- php3_skip_variable(fp);
+ php_skip_variable(fp);
}
break;
break;
default:
- php3_skip_variable(fp); /* anything else isn't interesting */
+ php_skip_variable(fp); /* anything else isn't interesting */
break;
}
}
return;
}
fread(filetype,sizeof(filetype),1,fp);
- if (!memcmp(filetype, php3_sig_gif, 3)) {
- result = php3_handle_gif (fp);
+ if (!memcmp(filetype, php_sig_gif, 3)) {
+ result = php_handle_gif (fp);
itype = 1;
- } else if (!memcmp(filetype, php3_sig_jpg, 3)) {
+ } else if (!memcmp(filetype, php_sig_jpg, 3)) {
if (info) {
- result = php3_handle_jpeg(fp,*info);
+ result = php_handle_jpeg(fp,*info);
} else {
- result = php3_handle_jpeg(fp,NULL);
+ result = php_handle_jpeg(fp,NULL);
}
itype = 2;
- } else if (!memcmp(filetype, php3_sig_png, 3)) {
+ } else if (!memcmp(filetype, php_sig_png, 3)) {
fseek(fp, 0L, SEEK_SET);
fread(pngtype, sizeof(pngtype), 1, fp);
- if (!memcmp(pngtype, php3_sig_png, 8)) {
- result = php3_handle_png(fp);
+ if (!memcmp(pngtype, php_sig_png, 8)) {
+ result = php_handle_png(fp);
itype = 3;
} else {
php_error(E_WARNING, "PNG file corrupted by ASCII conversion");
PHPAPI void php_print_info(int flag)
{
char **env,*tmp1,*tmp2;
- char *php3_uname;
+ char *php_uname;
int expose_php = INI_INT("expose_php");
#if WIN32|WINNT
- char php3_windows_uname[256];
+ char php_windows_uname[256];
DWORD dwBuild=0;
DWORD dwVersion = GetVersion();
DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
// Get build numbers for Windows NT or Win95
if (dwVersion < 0x80000000){
dwBuild = (DWORD)(HIWORD(dwVersion));
- snprintf(php3_windows_uname,255,"%s %d.%d build %d","Windows NT",dwWindowsMajorVersion,dwWindowsMinorVersion,dwBuild);
+ snprintf(php_windows_uname,255,"%s %d.%d build %d","Windows NT",dwWindowsMajorVersion,dwWindowsMinorVersion,dwBuild);
} else {
- snprintf(php3_windows_uname,255,"%s %d.%d","Windows 95/98",dwWindowsMajorVersion,dwWindowsMinorVersion);
+ snprintf(php_windows_uname,255,"%s %d.%d","Windows 95/98",dwWindowsMajorVersion,dwWindowsMinorVersion);
}
- php3_uname = php3_windows_uname;
+ php_uname = php_windows_uname;
#else
- php3_uname=PHP_UNAME;
+ php_uname=PHP_UNAME;
#endif
}
PUTS("?=PHPE9568F34-D428-11d2-A769-00AA001ACF42\" border=\"0\" align=\"right\"></a>\n");
}
- php_printf("System: %s<br>Build Date: %s\n<br>", php3_uname, __DATE__);
+ php_printf("System: %s<br>Build Date: %s\n<br>", php_uname, __DATE__);
#ifdef CONFIGURE_COMMAND
php_printf("Configure command: %s<br>\n", CONFIGURE_COMMAND);
#endif
#define M_APP14 0xee
#define M_APP15 0xef
-static int php3_iptc_put1(FILE *fp,int spool,unsigned char c,unsigned char **spoolbuf)
+static int php_iptc_put1(FILE *fp,int spool,unsigned char c,unsigned char **spoolbuf)
{
if (spool > 0)
PUTC(c);
return c;
}
-static int php3_iptc_get1(FILE *fp,int spool,unsigned char **spoolbuf)
+static int php_iptc_get1(FILE *fp,int spool,unsigned char **spoolbuf)
{
int c;
char cc;
return c;
}
-static int php3_iptc_read_remaining(FILE *fp,int spool,unsigned char **spoolbuf)
+static int php_iptc_read_remaining(FILE *fp,int spool,unsigned char **spoolbuf)
{
int c;
- while ((c = php3_iptc_get1(fp,spool,spoolbuf)) != EOF) continue;
+ while ((c = php_iptc_get1(fp,spool,spoolbuf)) != EOF) continue;
return M_EOI;
}
-static int php3_iptc_skip_variable(FILE *fp,int spool,unsigned char **spoolbuf)
+static int php_iptc_skip_variable(FILE *fp,int spool,unsigned char **spoolbuf)
{
unsigned int length;
int c1,c2;
- if ((c1 = php3_iptc_get1(fp,spool,spoolbuf)) == EOF) return M_EOI;
+ if ((c1 = php_iptc_get1(fp,spool,spoolbuf)) == EOF) return M_EOI;
- if ((c2 = php3_iptc_get1(fp,spool,spoolbuf)) == EOF) return M_EOI;
+ if ((c2 = php_iptc_get1(fp,spool,spoolbuf)) == EOF) return M_EOI;
length = (((unsigned char) c1) << 8) + ((unsigned char) c2);
length -= 2;
while (length--)
- if (php3_iptc_get1(fp,spool,spoolbuf) == EOF) return M_EOI;
+ if (php_iptc_get1(fp,spool,spoolbuf) == EOF) return M_EOI;
return 0;
}
-static int php3_iptc_nextmarker(FILE *fp,int spool,unsigned char **spoolbuf)
+static int php_iptc_next_marker(FILE *fp,int spool,unsigned char **spoolbuf)
{
int c;
/* skip unimportant stuff */
- c = php3_iptc_get1(fp,spool,spoolbuf);
+ c = php_iptc_get1(fp,spool,spoolbuf);
if (c == EOF) return M_EOI;
while (c != 0xff) {
- if ((c = php3_iptc_get1(fp,spool,spoolbuf)) == EOF)
+ if ((c = php_iptc_get1(fp,spool,spoolbuf)) == EOF)
return M_EOI; /* we hit EOF */
}
/* get marker byte, swallowing possible padding */
do {
- c = php3_iptc_get1(fp,0,0);
+ c = php_iptc_get1(fp,0,0);
if (c == EOF)
return M_EOI; /* we hit EOF */
else
if (c == 0xff)
- php3_iptc_put1(fp,spool,(unsigned char)c,spoolbuf);
+ php_iptc_put1(fp,spool,(unsigned char)c,spoolbuf);
} while (c == 0xff);
return (unsigned int) c;
}
}
- if (php3_iptc_get1(fp,spool,poi?&poi:0) != 0xFF) {
+ if (php_iptc_get1(fp,spool,poi?&poi:0) != 0xFF) {
fclose(fp);
RETURN_FALSE;
}
- if (php3_iptc_get1(fp,spool,poi?&poi:0) != 0xD8) {
+ if (php_iptc_get1(fp,spool,poi?&poi:0) != 0xD8) {
fclose(fp);
RETURN_FALSE;
}
while (!done) {
- marker = php3_iptc_nextmarker(fp,spool,poi?&poi:0);
+ marker = php_iptc_next_marker(fp,spool,poi?&poi:0);
if (marker == M_EOI) { /* EOF */
break;
} else if (marker != M_APP13) {
- php3_iptc_put1(fp,spool,(unsigned char)marker,poi?&poi:0);
+ php_iptc_put1(fp,spool,(unsigned char)marker,poi?&poi:0);
}
switch (marker) {
case M_APP13:
/* we are going to write a new APP13 marker, so don't output the old one */
- php3_iptc_skip_variable(fp,0,0);
- php3_iptc_read_remaining(fp,spool,poi?&poi:0);
+ php_iptc_skip_variable(fp,0,0);
+ php_iptc_read_remaining(fp,spool,poi?&poi:0);
done = 1;
break;
case M_APP0:
/* APP0 is in each and every JPEG, so when we hit APP0 we insert our new APP13! */
- php3_iptc_skip_variable(fp,spool,poi?&poi:0);
+ php_iptc_skip_variable(fp,spool,poi?&poi:0);
if (len & 1) len++; /* make the length even */
psheader[ 3 ] = (len+28)&0xff;
for (inx = 0; inx < 28; inx++)
- php3_iptc_put1(fp,spool,psheader[inx],poi?&poi:0);
+ php_iptc_put1(fp,spool,psheader[inx],poi?&poi:0);
- php3_iptc_put1(fp,spool,(unsigned char)(len>>8),poi?&poi:0);
- php3_iptc_put1(fp,spool,(unsigned char)(len&0xff),poi?&poi:0);
+ php_iptc_put1(fp,spool,(unsigned char)(len>>8),poi?&poi:0);
+ php_iptc_put1(fp,spool,(unsigned char)(len&0xff),poi?&poi:0);
for (inx = 0; inx < len; inx++)
- php3_iptc_put1(fp,spool,(*iptcdata)->value.str.val[inx],poi?&poi:0);
+ php_iptc_put1(fp,spool,(*iptcdata)->value.str.val[inx],poi?&poi:0);
break;
case M_SOS:
/* we hit data, no more marker-inserting can be done! */
- php3_iptc_read_remaining(fp,spool,poi?&poi:0);
+ php_iptc_read_remaining(fp,spool,poi?&poi:0);
done = 1;
break;
default:
- php3_iptc_skip_variable(fp,spool,poi?&poi:0);
+ php_iptc_skip_variable(fp,spool,poi?&poi:0);
break;
}
}
headers = (*argv[3])->value.str.val;
}
- if (_php3_mail(to, subject, message, headers)){
+ if (php_mail(to, subject, message, headers)){
RETURN_TRUE;
} else {
RETURN_FALSE;
}
/* }}} */
-int _php3_mail(char *to, char *subject, char *message, char *headers)
+int php_mail(char *to, char *subject, char *message, char *headers)
{
#if MSVC5
int tsm_err;
static int little_endian_long_map[4];
-static void _php3_pack(pval *val, int size, int *map, char *output)
+static void php_pack(pval *val, int size, int *map, char *output)
{
int i;
char *v;
case 'c': case 'C': {
while (arg-- > 0) {
- _php3_pack(argv[currentarg++], 1, byte_map, &output[outputpos]);
+ php_pack(argv[currentarg++], 1, byte_map, &output[outputpos]);
outputpos++;
}
break;
}
while (arg-- > 0) {
- _php3_pack(argv[currentarg++], 2, map, &output[outputpos]);
+ php_pack(argv[currentarg++], 2, map, &output[outputpos]);
outputpos += 2;
}
break;
case 'i': case 'I': {
while (arg-- > 0) {
- _php3_pack(argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
+ php_pack(argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
outputpos += sizeof(int);
}
break;
}
while (arg-- > 0) {
- _php3_pack(argv[currentarg++], 4, map, &output[outputpos]);
+ php_pack(argv[currentarg++], 4, map, &output[outputpos]);
outputpos += 4;
}
break;
/* }}} */
-static long _php3_unpack(char *data, int size, int issigned, int *map)
+static long php_unpack(char *data, int size, int issigned, int *map)
{
long result;
char *cresult = (char *)&result;
case 'c': case 'C': {
int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0;
- long v = _php3_unpack(&input[inputpos], 1, issigned, byte_map);
+ long v = php_unpack(&input[inputpos], 1, issigned, byte_map);
add_assoc_long(return_value, n, v);
break;
}
map = little_endian_short_map;
}
- v = _php3_unpack(&input[inputpos], 2, issigned, map);
+ v = php_unpack(&input[inputpos], 2, issigned, map);
add_assoc_long(return_value, n, v);
break;
}
issigned = input[inputpos + (machine_little_endian ? (sizeof(int) - 1) : 0)] & 0x80;
}
- v = _php3_unpack(&input[inputpos], sizeof(int), issigned, int_map);
+ v = php_unpack(&input[inputpos], sizeof(int), issigned, int_map);
add_assoc_long(return_value, n, v);
break;
}
map = little_endian_long_map;
}
- v = _php3_unpack(&input[inputpos], 4, issigned, map);
+ v = php_unpack(&input[inputpos], 4, issigned, map);
add_assoc_long(return_value, n, v);
break;
}
#include "ext/standard/basic_functions.h"
-static void _php3_statpage(void)
+static void php_statpage(void)
{
#if !APACHE
char *path;
{
BLS_FETCH();
- _php3_statpage();
+ php_statpage();
return (BG(page_uid));
}
{
BLS_FETCH();
- _php3_statpage();
+ php_statpage();
if (BG(page_inode) < 0) {
RETURN_FALSE;
} else {
{
BLS_FETCH();
- _php3_statpage();
+ php_statpage();
if (BG(page_mtime) < 0) {
RETURN_FALSE;
} else {
#ifndef _PHP_DIR_H
#define _PHP_DIR_H
-extern zend_module_entry php3_dir_module_entry;
-#define php3_dir_module_ptr &php3_dir_module_entry
+extern zend_module_entry php_dir_module_entry;
+#define php_dir_module_ptr &php_dir_module_entry
/* directory functions */
extern PHP_MINIT_FUNCTION(dir);
PHP_FUNCTION(readdir);
PHP_FUNCTION(getdir);
-#define phpext_dir_ptr php3_dir_module_ptr
+#define phpext_dir_ptr php_dir_module_ptr
#endif /* _PHP_DIR_H */
PHP_FUNCTION(touch);
PHP_FUNCTION(clearstatcache);
-extern zend_module_entry php3_filestat_module_entry;
-#define php3_filestat_module_ptr &php3_filestat_module_entry
+extern zend_module_entry php_filestat_module_entry;
+#define php_filestat_module_ptr &php_filestat_module_entry
-#define phpext_filestat_ptr php3_filestat_module_ptr
+#define phpext_filestat_ptr php_filestat_module_ptr
#endif /* _FILESTAT_H */
PHP_FUNCTION(mail);
PHP_MINFO_FUNCTION(mail);
-extern int _php3_mail(char *to, char *subject, char *message, char *headers);
+extern int php_mail(char *to, char *subject, char *message, char *headers);
#else
#define mail_module_ptr NULL
/* $Id$ */
-/* Synced with php3 revision 1.43 1999-06-16 [ssb] */
+/* Synced with php 3.0 revision 1.43 1999-06-16 [ssb] */
#ifndef _PHPSTRING_H
#define _PHPSTRING_H
var_type = php_check_ident_type(var);
if (var_type == GPC_INDEXED_ARRAY) {
- ind = php3_get_ident_index(var);
+ ind = php_get_ident_index(var);
if (PG(magic_quotes_gpc)) {
array_index = php_addslashes(ind, 0, NULL, 1);
} else {
/* Insert it */
if (array_index) {
/* indexed array */
- if (php3_check_type(array_index) == IS_LONG) {
+ if (php_check_type(array_index) == IS_LONG) {
/* numeric index */
zend_hash_index_update(gpc_element->value.ht, atol(array_index), &array_element, sizeof(pval *), NULL); /* s[array_index]=tmp */
} else {
if (val) { /* have a value */
*val++ = '\0';
/* FIXME: XXX: not binary safe, discards returned length */
- _php3_urldecode(var, strlen(var));
- _php3_urldecode(val, strlen(val));
+ php_url_decode(var, strlen(var));
+ php_url_decode(val, strlen(val));
php_parse_gpc_data2(val,var,array_ptr ELS_CC PLS_CC);
}
if (arg == PARSE_COOKIE) {
/*
* Converting HEX char to INT value
*/
-static char _php3_hex2int(int c)
+static char php_hex2int(int c)
{
if ( isdigit(c) )
{
( isdigit((int)str[i+2]) || (str[i+2]<='F' && str[i+2]>='A'))
)
{
- str[j++] = (_php3_hex2int((int)str[i+1]) << 4 )
- + _php3_hex2int((int)str[i+2]);
+ str[j++] = (php_hex2int((int)str[i+1]) << 4 )
+ + php_hex2int((int)str[i+2]);
i += 3;
}
else if ( str[i] == 13 )
return_value->type = IS_LONG;
/*
* Melo: hmms.. randomMT() returns 32 random bits...
- * Yet, the previous php3_rand only returns 31 at most.
+ * Yet, the previous php_rand only returns 31 at most.
* So I put a right shift to loose the lsb. It *seems*
* better than clearing the msb.
* Update:
return_value->type = IS_LONG;
/*
* Melo: it could be 2^^32 but we only use 2^^31 to maintain
- * compatibility with the previous php3_rand
+ * compatibility with the previous php_rand
*/
return_value->value.lval = 2147483647; /* 2^^31 */
}
#define NS 10
/*
- * _php3_reg_eprint - convert error number to name
+ * php_reg_eprint - convert error number to name
*/
-static void _php3_reg_eprint(int err, regex_t *re) {
+static void php_reg_eprint(int err, regex_t *re) {
char *buf = NULL, *message = NULL;
size_t len;
size_t buf_len;
STR_FREE(message);
}
-static void _php3_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
+static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
{
pval **regex, /* Regular expression */
**findin, /* String to apply expression to */
}
if (err) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
RETURN_FALSE;
}
/* actually execute the regular expression */
err = regexec(&re, string, (size_t) NS, subs, 0);
if (err && err != REG_NOMATCH) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
regfree(&re);
RETURN_FALSE;
}
buf = emalloc(string_len);
if (!buf) {
- php_error(E_WARNING, "Unable to allocate memory in _php3_ereg");
+ php_error(E_WARNING, "Unable to allocate memory in php_ereg");
RETURN_FALSE;
}
Regular expression match */
PHP_FUNCTION(ereg)
{
- _php3_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
Case-insensitive regular expression match */
PHP_FUNCTION(eregi)
{
- _php3_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
/* this is the meat and potatoes of regex replacement! */
-char *_php3_regreplace(const char *pattern, const char *replace, const char *string, int icase, int extended)
+char *php_reg_replace(const char *pattern, const char *replace, const char *string, int icase, int extended)
{
regex_t re;
regmatch_t subs[NS];
copts |= REG_EXTENDED;
err = regcomp(&re, pattern, copts);
if (err) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
return ((char *) -1);
}
buf_len = 2 * string_len + 1;
buf = emalloc(buf_len * sizeof(char));
if (!buf) {
- php_error(E_WARNING, "Unable to allocate memory in _php3_regreplace");
+ php_error(E_WARNING, "Unable to allocate memory in php_reg_replace");
regfree(&re);
return ((char *) -1);
}
err = regexec(&re, &string[pos], (size_t) NS, subs, (pos ? REG_NOTBOL : 0));
if (err && err != REG_NOMATCH) {
- _php3_reg_eprint(err, &re);
+ php_reg_eprint(err, &re);
regfree(&re);
return ((char *) -1);
}
return (buf);
}
-static void _php3_eregreplace(INTERNAL_FUNCTION_PARAMETERS, int icase)
+static void php_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase)
{
pval **arg_pattern,
**arg_replace,
string = empty_string;
/* do the actual work */
- ret = _php3_regreplace(pattern, replace, string, icase, 1);
+ ret = php_reg_replace(pattern, replace, string, icase, 1);
if (ret == (char *) -1) {
RETVAL_FALSE;
} else {
Replace regular expression */
PHP_FUNCTION(ereg_replace)
{
- _php3_eregreplace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
Case insensitive replace regular expression */
PHP_FUNCTION(eregi_replace)
{
- _php3_eregreplace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
extern zend_module_entry regexp_module_entry;
#define regexp_module_ptr ®exp_module_entry
-char *_php3_regreplace(const char *pattern, const char *replace, const char *string, int icase, int extended);
+char *php_reg_replace(const char *pattern, const char *replace, const char *string, int icase, int extended);
PHP_FUNCTION(ereg);
PHP_FUNCTION(eregi);
/* $Id$ */
-/* Synced with php3 revision 1.193 1999-06-16 [ssb] */
+/* Synced with php 3.0 revision 1.193 1999-06-16 [ssb] */
#include <stdio.h>
#include "php.h"
*
* Note that leading zeroes automatically force a STRING type
*/
-int php3_check_type(char *str)
+int php_check_type(char *str)
{
char *s;
int type = IS_LONG;
return (IS_STRING);
return (type);
-} /* php3_check_type */
+} /* php_check_type */
/*
* 0 - simple variable
return (GPC_INDEXED_ARRAY);
}
-char *php3_get_ident_index(char *str)
+char *php_get_ident_index(char *str)
{
char *temp;
char *s, *t;
#ifndef _TYPE_H
#define _TYPE_H
-extern int php3_check_type(char *str);
+extern int php_check_type(char *str);
extern int php_check_ident_type(char *str);
-extern char *php3_get_ident_index(char *str);
+extern char *php_get_ident_index(char *str);
#define GPC_REGULAR 0x1
#define GPC_INDEXED_ARRAY 0x2
}
/* }}} */
-static int php3_htoi(char *s)
+static int php_htoi(char *s)
{
int value;
int c;
static unsigned char hexchars[] = "0123456789ABCDEF";
-char *_php3_urlencode(char *s, int len)
+char *php_url_encode(char *s, int len)
{
register int x, y;
unsigned char *str;
var_reset(return_value);
return;
}
- str = _php3_urlencode((*arg)->value.str.val, (*arg)->value.str.len);
+ str = php_url_encode((*arg)->value.str.val, (*arg)->value.str.len);
RETVAL_STRING(str, 1);
efree(str);
}
*return_value = **arg;
zval_copy_ctor(return_value);
- len = _php3_urldecode(return_value->value.str.val, return_value->value.str.len);
+ len = php_url_decode(return_value->value.str.val, return_value->value.str.len);
return_value->value.str.len = len;
}
/* }}} */
-int _php3_urldecode(char *str, int len)
+int php_url_decode(char *str, int len)
{
char *dest = str;
char *data = str;
*dest = ' ';
else if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1)) && isxdigit((int) *(data + 2))) {
#ifndef CHARSET_EBCDIC
- *dest = (char) php3_htoi(data + 1);
+ *dest = (char) php_htoi(data + 1);
#else
- *dest = os_toebcdic[(char) php3_htoi(data + 1)];
+ *dest = os_toebcdic[(char) php_htoi(data + 1)];
#endif
data += 2;
len -= 2;
return dest - str;
}
-char *_php3_rawurlencode(char *s, int len)
+char *php_raw_url_encode(char *s, int len)
{
register int x, y;
unsigned char *str;
if (!(*arg)->value.str.len) {
RETURN_FALSE;
}
- str = _php3_rawurlencode((*arg)->value.str.val, (*arg)->value.str.len);
+ str = php_raw_url_encode((*arg)->value.str.val, (*arg)->value.str.len);
RETVAL_STRING(str, 1);
efree(str);
}
while (len--) {
if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1)) && isxdigit((int) *(data + 2))) {
#ifndef CHARSET_EBCDIC
- *dest = (char) php3_htoi(data + 1);
+ *dest = (char) php_htoi(data + 1);
#else
- *dest = os_toebcdic[(char) php3_htoi(data + 1)];
+ *dest = os_toebcdic[(char) php_htoi(data + 1)];
#endif
data += 2;
len -= 2;
void free_url(url *);
extern url *url_parse(char *);
-extern int _php3_urldecode(char *, int); /* return value: length of decoded string */
-extern char *_php3_urlencode(char *, int);
+extern int php_url_decode(char *, int); /* return value: length of decoded string */
+extern char *php_url_encode(char *, int);
extern int php_raw_url_decode(char *, int); /* return value: length of decoded string */
-extern char *_php3_rawurlencode(char *, int);
+extern char *php_raw_url_encode(char *, int);
PHP_FUNCTION(parse_url);
PHP_FUNCTION(urlencode);
}
efree(class_name);
- } else { /* old php3 data 'o' */
+ } else { /* old php 3.0 data 'o' */
ce = &zend_standard_class_def;
}
extern zend_module_entry sysvsem_module_entry;
#define sysvsem_module_ptr &sysvsem_module_entry
-extern int php3_minit_sysvsem(INIT_FUNC_ARGS);
-extern int php3_rinit_sysvsem(INIT_FUNC_ARGS);
-extern int php3_mshutdown_sysvsem(SHUTDOWN_FUNC_ARGS);
-extern int php3_rshutdown_sysvsem(SHUTDOWN_FUNC_ARGS);
-void php3_info_sysvsem(void);
+PHP_MINIT_FUNCTION(sysvsem);
PHP_FUNCTION(sysvsem_get);
PHP_FUNCTION(sysvsem_acquire);
PHP_FUNCTION(sysvsem_release);
int count; /* Acquire count for auto-release. */
} sysvsem_sem;
-extern sysvsem_module php3_sysvsem_module;
+extern sysvsem_module php_sysvsem_module;
#else
#endif
function_entry sysvsem_functions[] = {
- {"sem_get", php3_sysvsem_get, NULL},
- {"sem_acquire", php3_sysvsem_acquire, NULL},
- {"sem_release", php3_sysvsem_release, NULL},
+ PHP_FE(sem_get, NULL)
+ PHP_FE(sem_acquire, NULL)
+ PHP_FE(sem_release, NULL)
{NULL, NULL, NULL}
};
zend_module_entry sysvsem_module_entry = {
- "System V semaphores", sysvsem_functions, php3_minit_sysvsem, NULL, NULL, NULL, NULL, STANDARD_MODULE_PROPERTIES
+ "System V semaphores", sysvsem_functions, PHP_MINIT(sysvsem), NULL, NULL, NULL, NULL, STANDARD_MODULE_PROPERTIES
};
#if COMPILE_DL
#endif
-THREAD_LS sysvsem_module php3_sysvsem_module;
+THREAD_LS sysvsem_module php_sysvsem_module;
/* Semaphore functions using System V semaphores. Each semaphore
* actually consists of three semaphores allocated as a unit under the
* SYSVSEM_SEM to max_acquire. This allows max_acquire to be set and
* track the PHP code without having a global init routine or external
* semaphore init code. Except see the bug regarding a race condition
- * php3_sysvsem_get(). Semaphore 2 (SYSVSEM_SETVAL) serializes the
+ * php_sysvsem_get(). Semaphore 2 (SYSVSEM_SETVAL) serializes the
* calls to GETVAL SYSVSEM_USAGE and SETVAL SYSVSEM_SEM. It can be
* acquired only when it is zero.
*/
}
-int php3_minit_sysvsem(INIT_FUNC_ARGS)
+PHP_MINIT_FUNCTION(sysvsem)
{
- php3_sysvsem_module.le_sem = register_list_destructors(release_sysvsem_sem, NULL);
+ php_sysvsem_module.le_sem = register_list_destructors(release_sysvsem_sem, NULL);
return SUCCESS;
}
/* {{{ proto int sem_get(int key [, int max_acquire [, int perm]])
Return an id for the semaphore with the given key, and allow max_acquire (default 1) processes to acquire it simultaneously. */
-PHP_FUNCTION(sysvsem_get)
+PHP_FUNCTION(sem_get)
{
pval **arg_key, **arg_max_acquire, **arg_perm;
int key, max_acquire, perm;
sem_ptr->semid = semid;
sem_ptr->count = 0;
- return_value->value.lval = zend_list_insert(sem_ptr, php3_sysvsem_module.le_sem);
+ return_value->value.lval = zend_list_insert(sem_ptr, php_sysvsem_module.le_sem);
return_value->type = IS_LONG;
sem_ptr->id = (int)return_value->value.lval;
}
/* }}} */
-static void _php3_sysvsem_semop(INTERNAL_FUNCTION_PARAMETERS, int acquire)
+
+static void php_sysvsem_semop(INTERNAL_FUNCTION_PARAMETERS, int acquire)
{
pval **arg_id;
int id, type;
}
sem_ptr = (sysvsem_sem *) zend_list_find(id, &type);
- if (type!=php3_sysvsem_module.le_sem) {
+ if (type!=php_sysvsem_module.le_sem) {
php_error(E_WARNING, "%d is not a SysV semaphore index", id);
RETURN_FALSE;
}
/* {{{ proto int sem_acquire(int id)
Acquires the semaphore with the given id, blocking if necessary. */
-PHP_FUNCTION(sysvsem_acquire)
+PHP_FUNCTION(sem_acquire)
{
- _php3_sysvsem_semop(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+ php_sysvsem_semop(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
/* {{{ proto int sem_release(int id)
Releases the semaphore with the given id. */
-PHP_FUNCTION(sysvsem_release)
+PHP_FUNCTION(sem_release)
{
- _php3_sysvsem_semop(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+ php_sysvsem_semop(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
PHP_FUNCTION(shm_put_var);
PHP_FUNCTION(shm_get_var);
PHP_FUNCTION(shm_remove_var);
-extern int php3int_put_shmdata(sysvshm_chunk_head *ptr,long key,char *data, long len);
-extern long php3int_check_shmdata(sysvshm_chunk_head *ptr, long key);
-extern int php3int_remove_shmdata(sysvshm_chunk_head *ptr, long shm_varpos);
+extern int php_put_shm_data(sysvshm_chunk_head *ptr,long key,char *data, long len);
+extern long php_check_shm_data(sysvshm_chunk_head *ptr, long key);
+extern int php_remove_shm_data(sysvshm_chunk_head *ptr, long shm_varpos);
-extern sysvshm_module php3_sysvshm_module;
+extern sysvshm_module php_sysvshm;
#else
#endif
-THREAD_LS sysvshm_module php3_sysvshm_module;
+THREAD_LS sysvshm_module php_sysvshm;
-static void php3i_release_sysvshm(sysvshm_shm *shm_ptr)
+static void php_release_sysvshm(sysvshm_shm *shm_ptr)
{
shmdt((void*)shm_ptr->ptr);
efree(shm_ptr);
PHP_MINIT_FUNCTION(sysvshm)
{
- php3_sysvshm_module.le_shm = register_list_destructors(php3i_release_sysvshm, NULL);
+ php_sysvshm.le_shm = register_list_destructors(php_release_sysvshm, NULL);
if (cfg_get_long("sysvshm.init_mem",
- &php3_sysvshm_module.init_mem)==FAILURE) {
- php3_sysvshm_module.init_mem=10000;
+ &php_sysvshm.init_mem)==FAILURE) {
+ php_sysvshm.init_mem=10000;
}
return SUCCESS;
}
int ac = ARG_COUNT(ht);
shm_flag = 0666;
- shm_size = php3_sysvshm_module.init_mem;
+ shm_size = php_sysvshm.init_mem;
if(ac < 1 || ac > 3 || getParametersEx(ac, &arg_key, &arg_size, &arg_flag) == FAILURE) {
WRONG_PARAM_COUNT;
shm_list_ptr->key = shm_key;
shm_list_ptr->id = shm_id;
shm_list_ptr->ptr = chunk_ptr;
- list_id = zend_list_insert(shm_list_ptr, php3_sysvshm_module.le_shm);
+ list_id = zend_list_insert(shm_list_ptr, php_sysvshm.le_shm);
RETURN_LONG(list_id);
}
/* }}} */
key = (*arg_key)->value.lval;
shm_list_ptr = (sysvshm_shm *) zend_list_find(id, &type);
- if (type!=php3_sysvshm_module.le_shm) {
+ if (type!=php_sysvshm.le_shm) {
php_error(E_WARNING, "%d is not a SysV shared memory index", id);
RETURN_FALSE;
}
shm_var.value.str.val=0;
php_var_serialize(&shm_var,arg_var);
/* insert serialized variable into shared memory */
- ret=php3int_put_shmdata(shm_list_ptr->ptr,key,shm_var.value.str.val,shm_var.value.str.len);
+ ret=php_put_shm_data(shm_list_ptr->ptr,key,shm_var.value.str.val,shm_var.value.str.len);
/* free string */
efree(shm_var.value.str.val);
key = (*arg_key)->value.lval;
shm_list_ptr = (sysvshm_shm *) zend_list_find(id, &type);
- if (type!=php3_sysvshm_module.le_shm) {
+ if (type!=php_sysvshm.le_shm) {
php_error(E_WARNING, "%d is not a SysV shared memory index", id);
RETURN_FALSE;
}
/* setup string-variable and serialize */
/* get serialized variable from shared memory */
- shm_varpos=php3int_check_shmdata((shm_list_ptr->ptr),key);
+ shm_varpos=php_check_shm_data((shm_list_ptr->ptr),key);
if(shm_varpos<0) {
php_error(E_WARNING, "variable key %d doesn't exist", key);
key = (*arg_key)->value.lval;
shm_list_ptr = (sysvshm_shm *) zend_list_find(id, &type);
- if (type!=php3_sysvshm_module.le_shm) {
+ if (type!=php_sysvshm.le_shm) {
php_error(E_WARNING, "%d is not a SysV shared memory index", id);
RETURN_FALSE;
}
- shm_varpos=php3int_check_shmdata((shm_list_ptr->ptr),key);
+ shm_varpos=php_check_shm_data((shm_list_ptr->ptr),key);
if(shm_varpos<0) {
php_error(E_WARNING, "variable key %d doesn't exist", key);
RETURN_FALSE;
}
- php3int_remove_shmdata((shm_list_ptr->ptr),shm_varpos);
+ php_remove_shm_data((shm_list_ptr->ptr),shm_varpos);
RETURN_TRUE;
}
/* }}} */
/* inserts an ascii-string into shared memory */
-int php3int_put_shmdata(sysvshm_chunk_head *ptr,long key,char *data, long len) {
+int php_put_shm_data(sysvshm_chunk_head *ptr,long key,char *data, long len) {
sysvshm_chunk* shm_var;
long total_size;
long shm_varpos;
return -1; /* not enough memeory */
}
- if((shm_varpos=php3int_check_shmdata(ptr,key))>0) {
- php3int_remove_shmdata(ptr, shm_varpos);
+ if((shm_varpos=php_check_shm_data(ptr,key))>0) {
+ php_remove_shm_data(ptr, shm_varpos);
}
shm_var=(sysvshm_chunk*)((char *)ptr+ptr->end);
shm_var->key=key;
}
-long php3int_check_shmdata(sysvshm_chunk_head *ptr, long key) {
+long php_check_shm_data(sysvshm_chunk_head *ptr, long key) {
long pos;
sysvshm_chunk *shm_var;
}
-int php3int_remove_shmdata(sysvshm_chunk_head *ptr, long shm_varpos) {
+int php_remove_shm_data(sysvshm_chunk_head *ptr, long shm_varpos) {
sysvshm_chunk *chunk_ptr, *next_chunk_ptr;
long memcpy_len;
projects / php / commitdiff