ZEND_METHOD(hprose_bytes_io, readuntil) { #if PHP_MAJOR_VERSION < 7 char *s; int32_t l; #else zend_string *s; #endif char *tag; length_t len; HPROSE_THIS(bytes_io); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &tag, &len) == FAILURE) { RETURN_NULL(); } #if PHP_MAJOR_VERSION < 7 if (len > 0) { s = hprose_bytes_io_readuntil(_this, tag[0], &l); } else { s = hprose_bytes_io_readfull(_this, &l); } RETURN_STRINGL_0(s, l); #else if (len > 0) { s = hprose_bytes_io_readuntil(_this, tag[0]); } else { s = hprose_bytes_io_readfull(_this); } RETURN_STR(s); #endif }
U_CFUNC PHP_FUNCTION(rbbi_get_binary_rules) { BREAKITER_METHOD_INIT_VARS; object = getThis(); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "rbbi_get_binary_rules: bad arguments", 0); RETURN_FALSE; } BREAKITER_METHOD_FETCH_OBJECT; uint32_t rules_len; const uint8_t *rules = fetch_rbbi(bio)->getBinaryRules(rules_len); if (rules_len > INT_MAX - 1) { intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio), "rbbi_get_binary_rules: the rules are too large", 0); RETURN_FALSE; } zend_string *ret_rules = zend_string_alloc(rules_len, 0); memcpy(ret_rules->val, rules, rules_len); ret_rules->val[rules_len] = '\0'; RETURN_STR(ret_rules); }
ZEND_METHOD(hprose_bytes_io, toString) { HPROSE_THIS(bytes_io); #if PHP_MAJOR_VERSION < 7 RETURN_STRINGL_0(hprose_bytes_io_to_string(_this), _this->len); #else RETURN_STR(hprose_bytes_io_to_string(_this)); #endif }
/** public function ION\HTTP\Message::getProtocolVersion() : string */ CLASS_METHOD(ION_HTTP_Message, getProtocolVersion) { ion_http_message * message = ION_THIS_OBJECT(ion_http_message); if(message->version) { RETURN_STR(zend_string_copy(message->version)); } else { RETURN_STRINGL(ION_HTTP_VERSION_DEFAULT, sizeof(ION_HTTP_VERSION_DEFAULT) - 1); } }
/* * $levelctl(LEVELS) * $levelctl(ADD name) * $levelctl(ALIAS old-name new-name) * $levelctl(LOOKUP name-or-number) * $levelctl(NORMALIZE string) */ char *levelctl (char *input) { char *listc, *retval; const char *newlevel, *oldlevel; int oldnum, newnum; GET_FUNC_ARG(listc, input); if (!my_strnicmp(listc, "LEVELS", 2)) { retval = get_all_levels(); RETURN_MSTR(retval); } else if (!my_strnicmp(listc, "ADD", 2)) { GET_FUNC_ARG(newlevel, input); newnum = add_new_level(newlevel); RETURN_INT(newnum); } else if (!my_strnicmp(listc, "ALIAS", 2)) { GET_FUNC_ARG(oldlevel, input); GET_FUNC_ARG(newlevel, input); oldnum = str_to_level(oldlevel); newnum = add_new_level_alias(oldnum, newlevel); RETURN_INT(newnum); } else if (!my_strnicmp(listc, "LOOKUP", 2)) { GET_FUNC_ARG(newlevel, input); if (is_number(newlevel)) { oldnum = STR2INT(newlevel); oldlevel = level_to_str(oldnum); RETURN_STR(oldlevel); } else { oldnum = str_to_level(newlevel); RETURN_INT(oldnum); } } else if (!my_strnicmp(listc, "NORMALIZE", 1)) { Mask m; const char *r; char *err = NULL; mask_unsetall(&m); str_to_mask(&m, input, &err); /* Errors are ignored */ r = mask_to_str(&m); RETURN_STR(r); } RETURN_EMPTY; }
ZEND_METHOD(hprose_bytes_io, readfull) { HPROSE_THIS(bytes_io); #if PHP_MAJOR_VERSION < 7 int32_t l; char *s = hprose_bytes_io_readfull(_this, &l); RETURN_STRINGL_0(s, l); #else RETURN_STR(hprose_bytes_io_readfull(_this)); #endif }
ZEND_METHOD(hprose_bytes_io, getc) { HPROSE_THIS(bytes_io); if (HB_INITED_P(_this) && (HB_POS_P(_this) < HB_LEN_P(_this))) { #if PHP_MAJOR_VERSION < 7 RETURN_STRINGL_0(hprose_bytes_io_read(_this, 1), 1); #else RETURN_STR(hprose_bytes_io_read(_this, 1)); #endif } RETURN_EMPTY_STRING(); }
/** * Returns the called in class in the current scope */ void zephir_get_called_class(zval *return_value) { if (EG(current_execute_data)->called_scope) { zend_string *ret = EG(current_execute_data)->called_scope->name; zend_string_addref(ret); RETURN_STR(ret); } if (!EG(scope)) { php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class"); } }
static PHP_METHOD(Operand, getName) { php_inspector_operand_t *operand = php_inspector_operand_this(); if (operand->type & IS_CV) { php_inspector_opline_t *opline = php_inspector_opline_fetch_from(Z_OBJ(operand->opline)); php_inspector_scope_t *scope = php_inspector_scope_fetch_from(Z_OBJ(opline->scope)); RETURN_STR(zend_string_copy(scope->ops->vars[EX_VAR_TO_NUM(operand->op->var)])); } }
/* {{{ proto char SessionHandler::create_sid() Wraps the old create_sid handler */ PHP_METHOD(SessionHandler, create_sid) { zend_string *id; PS_SANITY_CHECK; if (zend_parse_parameters_none() == FAILURE) { return; } id = PS(default_mod)->s_create_sid(&PS(mod_data)); RETURN_STR(id); }
/** * Replaces directory separators by the virtual separator */ void zephir_prepare_virtual_path(zval *return_value, zval *path, zval *virtual_separator) { unsigned int i; unsigned char ch; smart_str virtual_str = {0}; if (Z_TYPE_P(path) != IS_STRING || Z_TYPE_P(virtual_separator) != IS_STRING) { if (Z_TYPE_P(path) == IS_STRING) { RETURN_STR(zval_get_string(path)); } else { RETURN_EMPTY_STRING(); } return; } for (i = 0; i < Z_STRLEN_P(path); i++) { ch = Z_STRVAL_P(path)[i]; if (ch == '\0') { break; } if (ch == '/' || ch == '\\' || ch == ':') { smart_str_appendl(&virtual_str, Z_STRVAL_P(virtual_separator), Z_STRLEN_P(virtual_separator)); } else { smart_str_appendc(&virtual_str, tolower(ch)); } } smart_str_0(&virtual_str); if (virtual_str.s) { RETURN_STR(virtual_str.s); } else { RETURN_EMPTY_STRING(); } }
ZEND_METHOD(hprose_bytes_io, read) { long n; HPROSE_THIS(bytes_io); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &n) == FAILURE) { RETURN_NULL(); } if (HB_INITED_P(_this) && (HB_POS_P(_this) + n > HB_LEN_P(_this))) { n = HB_LEN_P(_this) - HB_POS_P(_this); } #if PHP_MAJOR_VERSION < 7 RETURN_STRINGL_0(hprose_bytes_io_read(_this, n), n); #else RETURN_STR(hprose_bytes_io_read(_this, n)); #endif }
// extern TF_Buffer TF_GetBuffer(TF_Buffer* buffer); static PHP_METHOD(TensorFlow_Buffer, __toString) { zend_string* result; // this t_tf_buffer_object* intern; t_tf_buffer* node; TF_Buffer* tf_buffer; intern = TF_BUFFER_P_ZV(getThis()); node = intern->ptr; tf_buffer = node->src; RETURN_STR(zend_string_init(tf_buffer->data, tf_buffer->length, 0)); }
/* {{{ proto bool SessionHandler::read(string id) Wraps the old read handler */ PHP_METHOD(SessionHandler, read) { zend_string *val; zend_string *key; PS_SANITY_CHECK_IS_OPEN; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) { return; } if (PS(default_mod)->s_read(&PS(mod_data), key, &val, PS(gc_maxlifetime)) == FAILURE) { RETURN_FALSE; } RETURN_STR(val); }
PHP_METHOD(jz_data, key) { zval *prop; zend_string *string; zend_ulong index; prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL); zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index); switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) { case HASH_KEY_IS_LONG: RETURN_LONG(index); break; case HASH_KEY_IS_STRING: RETURN_STR(zend_string_copy(string)); break; default: RETURN_FALSE; } }
/** {{{ proto public Yaf_Config_Simple::key(void) */ PHP_METHOD(yaf_config_simple, key) { zval *prop; zend_string *string; ulong index; prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL); zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index); switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) { case HASH_KEY_IS_LONG: RETURN_LONG(index); break; case HASH_KEY_IS_STRING: RETURN_STR(zend_string_copy(string)); break; default: RETURN_FALSE; } }
ZEND_METHOD(hprose_bytes_io, readString) { long n; HPROSE_THIS(bytes_io); #if PHP_MAJOR_VERSION < 7 char *s; int32_t l; #else zend_string *s; #endif if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &n) == FAILURE) { RETURN_NULL(); } #if PHP_MAJOR_VERSION < 7 s = hprose_bytes_io_read_string(_this, n, &l); RETURN_STRINGL_0(s, l); #else RETURN_STR(hprose_bytes_io_read_string(_this, n)); #endif }
/** * Serializes php variables without using the PHP userland */ void phalcon_serialize(zval *return_value, zval *var) { php_serialize_data_t var_hash; smart_str buf = {0}; PHP_VAR_SERIALIZE_INIT(var_hash); php_var_serialize(&buf, var, &var_hash); PHP_VAR_SERIALIZE_DESTROY(var_hash); if (EG(exception)) { smart_str_free(&buf); RETURN_FALSE; } if (buf.s) { RETURN_STR(buf.s); } else { RETURN_NULL(); } }
/* {{{ proto string SplDoublyLinkedList::serialize() Serializes storage */ SPL_METHOD(SplDoublyLinkedList, serialize) { spl_dllist_object *intern = Z_SPLDLLIST_P(getThis()); smart_str buf = {0}; spl_ptr_llist_element *current = intern->llist->head, *next; zval flags; php_serialize_data_t var_hash; if (zend_parse_parameters_none() == FAILURE) { return; } PHP_VAR_SERIALIZE_INIT(var_hash); /* flags */ ZVAL_LONG(&flags, intern->flags); php_var_serialize(&buf, &flags, &var_hash); zval_ptr_dtor(&flags); /* elements */ while (current) { smart_str_appendc(&buf, ':'); next = current->next; php_var_serialize(&buf, ¤t->data, &var_hash); current = next; } smart_str_0(&buf); /* done */ PHP_VAR_SERIALIZE_DESTROY(var_hash); if (buf.s) { RETURN_STR(buf.s); } else { RETURN_NULL(); } } /* }}} */
U_CFUNC PHP_FUNCTION(intlcal_get_error_message) { zend_string* message = NULL; CALENDAR_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, Calendar_ce_ptr) == FAILURE) { intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_get_error_message: bad arguments", 0 TSRMLS_CC ); RETURN_FALSE; } /* Fetch the object (without resetting its last error code ). */ co = Z_INTL_CALENDAR_P(object); if (co == NULL) RETURN_FALSE; /* Return last error message. */ message = intl_error_get_message(CALENDAR_ERROR_P(co) TSRMLS_CC); RETURN_STR(message); }
/** * Escapes HTML replacing special chars by entities */ void phalcon_escape_html(zval *return_value, zval *str, const zval *quote_style, const zval *charset) { zend_string *escaped; if (Z_TYPE_P(str) != IS_STRING) { /* Nothing to escape */ RETURN_ZVAL(str, 1, 0); } if (Z_TYPE_P(quote_style) != IS_LONG) { php_error_docref(NULL, E_WARNING, "Invalid quote_style supplied for phalcon_escape_html()"); RETURN_ZVAL(str, 1, 0); } if (Z_TYPE_P(charset) != IS_STRING) { php_error_docref(NULL, E_WARNING, "Invalid charset supplied for phalcon_escape_html()"); RETURN_ZVAL(str, 1, 0); } escaped = php_escape_html_entities((unsigned char*) Z_STRVAL_P(str), Z_STRLEN_P(str), 0, Z_LVAL_P(quote_style), Z_STRVAL_P(charset)); RETURN_STR(escaped); }
char * rubyeval (char *input) { VALUE rubyval; char * retval = NULL; if (input && *input) { ruby_startstop(1); rubyval = rb_rescue2(internal_rubyeval, (VALUE)input, eval_failed, 0, rb_eException, 0); if (rubyval == Qnil) retval = NULL; else { VALUE x; x = rb_obj_as_string(rubyval); retval = StringValuePtr(x); } } RETURN_STR(retval); /* XXX Is this malloced or not? */ }
/** * Returns the called in class in the current scope */ void zephir_get_called_class(zval *return_value) { #if PHP_VERSION_ID >= 70100 zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data)); if (called_scope) { ZVAL_STR(return_value, zend_string_dup(called_scope->name, 0)); } if (!zend_get_executed_scope()) { php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class"); } #else if (EG(current_execute_data)->called_scope) { zend_string *ret = EG(current_execute_data)->called_scope->name; zend_string_addref(ret); RETURN_STR(ret); } if (!EG(scope)) { php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class"); } #endif }
/** * Filter alphanum string */ void zephir_filter_alphanum(zval *return_value, zval *param) { unsigned int i; unsigned char ch; smart_str filtered_str = {0}; zval copy; int use_copy = 0; if (Z_TYPE_P(param) != IS_STRING) { use_copy = zend_make_printable_zval(param, ©); if (use_copy) { param = © } } for (i = 0; i < Z_STRLEN_P(param); i++) { ch = Z_STRVAL_P(param)[i]; if (ch == '\0') { break; } if (isalnum(ch)) { smart_str_appendc(&filtered_str, ch); } } if (use_copy) { zval_dtor(param); } smart_str_0(&filtered_str); if (filtered_str.s) { RETURN_STR(filtered_str.s); } else { RETURN_EMPTY_STRING(); } }
/* * $timerctl(REFNUM refnum) * $timerctl(ADD <refnum> <interval> <events> <commands> <subargs> <window>) * $timerctl(DELETE <refnum>) * $timerctl(GET <refnum> [LIST]) * $timerctl(SET <refnum> [ITEM] [VALUE]) * $timerctl(REFNUMS) * * [LIST] and [ITEM] are one of the following * TIMEOUT The precise time the timer will be executed * COMMAND The commands that will be executed * SUBARGS The vaule of $* used when this timer is executed * REPEATS The number of times this timer will be executed * INTERVAL The interval of time between executions * SERVER The server this timer bound to * WINDOW The window this timer bound to */ char * timerctl (char *input) { char * refstr; char * listc; Timer * t; int len; GET_FUNC_ARG(listc, input); len = strlen(listc); if (!my_strnicmp(listc, "REFNUM", len)) { GET_FUNC_ARG(refstr, input); if (!(t = get_timer(refstr))) RETURN_EMPTY; RETURN_STR(t->ref); } else if (!my_strnicmp(listc, "REFNUMS", len)) { char * retval = NULL; size_t clue = 0; for (t = PendingTimers; t; t = t->next) malloc_strcat_word_c(&retval, space, t->ref, DWORD_DWORDS, &clue); RETURN_MSTR(retval); } else if (!my_strnicmp(listc, "ADD", len)) { RETURN_EMPTY; /* XXX - Not implemented yet. */ } else if (!my_strnicmp(listc, "DELETE", len)) { GET_FUNC_ARG(refstr, input); if (!(t = get_timer(refstr))) RETURN_EMPTY; if (t->callback) RETURN_EMPTY; RETURN_INT(remove_timer(refstr)); } else if (!my_strnicmp(listc, "GET", len)) { GET_FUNC_ARG(refstr, input); if (!(t = get_timer(refstr))) RETURN_EMPTY; GET_FUNC_ARG(listc, input); len = strlen(listc); if (!my_strnicmp(listc, "TIMEOUT", len)) { return malloc_sprintf(NULL, "%ld %ld", (long) t->time.tv_sec, (long) t->time.tv_usec); } else if (!my_strnicmp(listc, "COMMAND", len)) { if (t->callback) RETURN_EMPTY; RETURN_STR(t->command); } else if (!my_strnicmp(listc, "SUBARGS", len)) { if (t->callback) RETURN_EMPTY; RETURN_STR(t->subargs); } else if (!my_strnicmp(listc, "REPEATS", len)) { RETURN_INT(t->events); } else if (!my_strnicmp(listc, "INTERVAL", len)) { return malloc_sprintf(NULL, "%ld %ld", (long) t->interval.tv_sec, (long) t->interval.tv_usec); } else if (!my_strnicmp(listc, "SERVER", len)) { if (t->domain != SERVER_TIMER) RETURN_INT(-1); RETURN_INT(t->domref); } else if (!my_strnicmp(listc, "WINDOW", len)) { if (t->domain != WINDOW_TIMER) RETURN_INT(-1); RETURN_INT(t->domref); } } else if (!my_strnicmp(listc, "SET", len)) { GET_FUNC_ARG(refstr, input); if (!(t = get_timer(refstr))) RETURN_EMPTY; /* Changing internal system timers is strictly prohibited */ if (t->callback) RETURN_EMPTY; GET_FUNC_ARG(listc, input); len = strlen(listc); if (!my_strnicmp(listc, "TIMEOUT", len)) { time_t tv_sec; long tv_usec; GET_INT_ARG(tv_sec, input); GET_INT_ARG(tv_usec, input); t->time.tv_sec = tv_sec; t->time.tv_usec = tv_usec; } else if (!my_strnicmp(listc, "COMMAND", len)) { malloc_strcpy((char **)&t->command, input); } else if (!my_strnicmp(listc, "SUBARGS", len)) { malloc_strcpy(&t->subargs, input); } else if (!my_strnicmp(listc, "REPEATS", len)) { long repeats; GET_INT_ARG(repeats, input); t->events = repeats; } else if (!my_strnicmp(listc, "INTERVAL", len)) { time_t tv_sec; long tv_usec; GET_INT_ARG(tv_sec, input); GET_INT_ARG(tv_usec, input); t->interval.tv_sec = tv_sec; t->interval.tv_usec = tv_usec; } else if (!my_strnicmp(listc, "SERVER", len)) { int refnum; GET_INT_ARG(refnum, input); t->domain = SERVER_TIMER; t->domref = refnum; } else if (!my_strnicmp(listc, "WINDOW", len)) { int refnum; GET_INT_ARG(refnum, input); t->domain = WINDOW_TIMER; t->domref = refnum; } } else RETURN_EMPTY; RETURN_EMPTY; }
/** * Perform escaping of non-alphanumeric characters to different formats */ void zephir_escape_multi(zval *return_value, zval *param, const char *escape_char, unsigned int escape_length, char escape_extra, int use_whitelist) { unsigned int i; zval copy; smart_str escaped_str = {0}; char machine_little_endian, *hex; int big_endian_long_map[4]; int use_copy = 0, machine_endian_check = 1; int issigned = 0; long value; if (Z_TYPE_P(param) != IS_STRING) { use_copy = zend_make_printable_zval(param, ©); if (use_copy) { param = © } } if (Z_STRLEN_P(param) <= 0) { RETURN_FALSE; } /** * This is how the big_ending_long_map is calculated as in 'pack' */ machine_little_endian = ((char *) &machine_endian_check)[0]; if (machine_little_endian) { big_endian_long_map[0] = 3; big_endian_long_map[1] = 2; big_endian_long_map[2] = 1; big_endian_long_map[3] = 0; } else { int size = sizeof(Z_LVAL_P(param)); big_endian_long_map[0] = size - 4; big_endian_long_map[1] = size - 3; big_endian_long_map[2] = size - 2; big_endian_long_map[3] = size - 1; } /** * The input must be a valid UTF-32 string */ if ((Z_STRLEN_P(param) % 4) != 0) { RETURN_FALSE; } for (i = 0; i < Z_STRLEN_P(param); i += 4) { issigned = Z_STRVAL_P(param)[i] & 0x80; value = 0; if (sizeof(long) > 4 && issigned) { value = ~INT_MAX; } value |= zephir_unpack(&Z_STRVAL_P(param)[i], 4, issigned, big_endian_long_map); if (sizeof(long) > 4) { value = (unsigned int) value; } /** * CSS 2.1 section 4.1.3: "It is undefined in CSS 2.1 what happens if a * style sheet does contain a character with Unicode codepoint zero." */ if (value == '\0') { RETURN_FALSE; } /** * Alphanumeric characters are not escaped */ if (value < 256 && isalnum(value)) { smart_str_appendc(&escaped_str, (unsigned char) value); continue; } /** * Chararters in the whitelist are left as they are */ if (use_whitelist) { switch (value) { case ' ': case '/': case '*': case '+': case '-': case '\t': case '\n': case '^': case '$': case '!': case '?': case '\\': case '#': case '}': case '{': case ')': case '(': case ']': case '[': case '.': case ',': case ':': case ';': case '_': case '|': smart_str_appendc(&escaped_str, (unsigned char) value); continue; } } /** * Convert character to hexadecimal */ hex = zephir_longtohex(value); /** * Append the escaped character */ smart_str_appendl(&escaped_str, escape_char, escape_length); smart_str_appendl(&escaped_str, hex, strlen(hex)); if (escape_extra != '\0') { smart_str_appendc(&escaped_str, escape_extra); } efree(hex); } if (use_copy) { zval_dtor(param); } smart_str_0(&escaped_str); if (escaped_str.s) { RETURN_STR(escaped_str.s); } else { RETURN_EMPTY_STRING(); } }
/* * $logctl(NEW) * $logctl(REFNUMS [ACTIVE|INACTIVE|ALL]) * $logctl(REFNUM log-desc) * $logctl(ADD log-desc [target]) * $logctl(DELETE log-desc [target]) * $logctl(GET <refnum> [LIST]) * $logctl(SET <refnum> [ITEM] [VALUE]) * $logctl(MATCH [pattern]) * $logctl(PMATCH [pattern]) * * [LIST] and [ITEM] are one of the following * REFNUM The refnum for the log (GET only) * NAME The logical name for the log * FILENAME The filename this log writes to * SERVER The server this log associates with (-1 for any) * TARGETS All of the targets for this log * LEVEL The Lastlog Level for this log * REWRITE The rewrite rule for this log * MANGLE The mangle rule for this log * STATUS 1 if log is on, 0 if log is off. * TYPE Either "TARGET", "WINDOW", or "SERVER" */ char *logctl (char *input) { char *refstr; char *listc; int val; Logfile *log; GET_FUNC_ARG(listc, input); if (!my_strnicmp(listc, "NEW", 3)) { log = new_logfile(); RETURN_INT(log->refnum); } else if (!my_strnicmp(listc, "LAST_CREATED", 12)) { RETURN_INT(last_logref); } else if (!my_strnicmp(listc, "REFNUMS", 7)) { char * retval = NULL; int active; GET_FUNC_ARG(refstr, input); if (!my_stricmp(refstr, "ACTIVE")) active = 1; else if (!my_stricmp(refstr, "INACTIVE")) active = 0; else if (!my_stricmp(refstr, "ALL")) active = -1; else RETURN_EMPTY; for (log = logfiles; log; log = log->next) { if (active != -1 && active != log->active) continue; malloc_strcat_word(&retval, space, ltoa(log->refnum), DWORD_NO); } RETURN_MSTR(retval); } else if (!my_strnicmp(listc, "REFNUM", 6)) { GET_FUNC_ARG(refstr, input); if (!(log = get_log_by_desc(refstr))) RETURN_EMPTY; RETURN_INT(log->refnum); } else if (!my_strnicmp(listc, "ADD", 2)) { GET_FUNC_ARG(refstr, input); if (!(log = get_log_by_desc(refstr))) RETURN_EMPTY; logfile_add(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "DELETE", 2)) { GET_FUNC_ARG(refstr, input); if (!(log = get_log_by_desc(refstr))) RETURN_EMPTY; logfile_remove(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "GET", 2)) { GET_FUNC_ARG(refstr, input); if (!(log = get_log_by_desc(refstr))) RETURN_EMPTY; GET_FUNC_ARG(listc, input); if (!my_strnicmp(listc, "REFNUM", 3)) { RETURN_INT(log->refnum); } else if (!my_strnicmp(listc, "NAME", 3)) { RETURN_STR(log->name); } else if (!my_strnicmp(listc, "FILENAME", 3)) { RETURN_STR(log->filename); } else if (!my_strnicmp(listc, "SERVER", 3)) { RETURN_INT(log->servref); } else if (!my_strnicmp(listc, "TARGETS", 3)) { char *ret = logfile_get_targets(log); RETURN_MSTR(ret); } else if (!my_strnicmp(listc, "LEVEL", 3)) { const char *ret = mask_to_str(&log->mask); RETURN_STR(ret); } else if (!my_strnicmp(listc, "REWRITE", 3)) { RETURN_STR(log->rewrite); } else if (!my_strnicmp(listc, "MANGLE", 3)) { RETURN_STR(log->mangle_desc); } else if (!my_strnicmp(listc, "STATUS", 3)) { RETURN_INT(log->active); } else if (!my_strnicmp(listc, "TYPE", 3)) { RETURN_STR(logtype[log->type]); } else if (!my_strnicmp(listc, "ACTIVITY", 1)) { RETURN_INT(log->activity); } } else if (!my_strnicmp(listc, "SET", 1)) { GET_FUNC_ARG(refstr, input); if (!(log = get_log_by_desc(refstr))) RETURN_EMPTY; GET_FUNC_ARG(listc, input); if (!my_strnicmp(listc, "NAME", 3)) { logfile_name(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "FILENAME", 3)) { logfile_filename(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "SERVER", 3)) { logfile_server(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "TARGETS", 3)) { clean_log_targets(log); logfile_add(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "LEVEL", 3)) { logfile_level(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "REWRITE", 3)) { logfile_rewrite(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "MANGLE", 3)) { logfile_mangle(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "STATUS", 3)) { GET_INT_ARG(val, input); if (val) logfile_on(log, &input); else logfile_off(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "TYPE", 3)) { logfile_type(log, &input); RETURN_INT(1); } else if (!my_strnicmp(listc, "ACTIVITY", 1)) { logfile_activity(log, &input); RETURN_INT(1); } } else if (!my_strnicmp(listc, "MATCH", 1)) { RETURN_EMPTY; /* Not implemented for now. */ } else if (!my_strnicmp(listc, "PMATCH", 1)) { RETURN_EMPTY; /* Not implemented for now. */ } else if (!my_strnicmp(listc, "CURRENT", 1)) { RETURN_INT(current_log_refnum); } else RETURN_EMPTY; RETURN_EMPTY; }