void SzbaseWrapper::set_prober_address( const std::string& address , unsigned port )
{
Szbase::GetObject()->SetProberAddress(
convert_string(base_name) ,
convert_string(address) ,
boost::lexical_cast<std::wstring>(port) );
}
int main (int argc, char *argv [])
{
int
index = 0;
byte
key [8],
value [8],
result [8],
tst_buf [8];
while (test_value [index][0] != '\0')
{
convert_string (key , test_value[index++]);
convert_string (value , test_value[index++]);
convert_string (result, test_value[index++]);
memcpy (tst_buf, value, 8);
if (crypt_encode ((byte *)tst_buf, 8, CRYPT_DES, (byte *) key))
{
if (memcmp (tst_buf, result, 8) != 0)
printf ("Error : line %d -> bad result\n",index/3);
else
putchar ('.');
}
else
printf ("\nEncrypt return FALSE\n");
}
return (EXIT_SUCCESS);
}
/* @builtin-bind { 'V', builtin_contextualdefunlibrary }, */
int builtin_contextualdefunlibrary(interpreter* interp) {
int status;
string cxt;
/* Get subcommand */
++interp->ip;
if (!is_ip_valid(interp)) {
print_error("Expected subcommand");
return 0;
}
switch (curr(interp)) {
case 's':
cxt = convert_string("@=");
cxt = append_cstr(cxt, current_context);
cxt = append_cstr(cxt, "\n");
break;
case 'e':
cxt = convert_string("@=*");
cxt = append_cstr(cxt, get_context_extension(current_context));
cxt = append_cstr(cxt, "\n");
break;
default:
print_error("Unknown subcommand");
return 0;
}
status = builtin_defunlibrary_common(interp, cxt, 'D');
free(cxt);
return status;
}
int main(int argc, char *argv[])
{
cmdname = "";
arg1 = NULL;
arg1len = 0;
arg2 = NULL;
arg2len = 0;
if (argv[1]) {
cmdname = "open";
arg1 = argv[1];
do_command();
cmdname = "";
arg1 = NULL;
}
switch (argc) {
case 1:
case 2:
while ((cmdname = tdb_getline("tdb> "))) {
arg2 = arg1 = NULL;
if ((arg1 = strchr((const char *)cmdname,' ')) != NULL) {
arg1++;
arg2 = arg1;
while (*arg2) {
if (*arg2 == ' ') {
*arg2++ = '\0';
break;
}
if ((*arg2++ == '\\') && (*arg2 == ' ')) {
arg2++;
}
}
}
if (arg1) arg1 = convert_string(arg1,&arg1len);
if (arg2) arg2 = convert_string(arg2,&arg2len);
if (do_command()) break;
}
break;
case 5:
arg2 = convert_string(argv[4],&arg2len);
case 4:
arg1 = convert_string(argv[3],&arg1len);
case 3:
cmdname = argv[2];
default:
do_command();
break;
}
if (tdb) tdb_close(tdb);
return 0;
}
void
seahorse_gpgme_uid_set_userid (SeahorseGpgmeUid *self, gpgme_user_id_t userid)
{
SeahorsePgpUid *base;
GObject *obj;
gpgme_user_id_t uid;
gchar *string;
gint index, i;
g_return_if_fail (SEAHORSE_IS_GPGME_UID (self));
g_return_if_fail (userid);
if (self->pv->userid)
g_return_if_fail (seahorse_gpgme_uid_is_same (self, userid));
/* Make sure that this userid is in the pubkey */
index = -1;
for (i = 0, uid = self->pv->pubkey->uids; uid; ++i, uid = uid->next) {
if(userid == uid) {
index = i;
break;
}
}
g_return_if_fail (index >= 0);
self->pv->userid = userid;
self->pv->gpgme_index = index;
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
g_object_notify (obj, "userid");
g_object_notify (obj, "gpgme_index");
base = SEAHORSE_PGP_UID (self);
string = convert_string (userid->comment);
seahorse_pgp_uid_set_comment (base, string);
g_free (string);
string = convert_string (userid->email);
seahorse_pgp_uid_set_email (base, string);
g_free (string);
string = convert_string (userid->name);
seahorse_pgp_uid_set_name (base, string);
g_free (string);
realize_signatures (self);
seahorse_pgp_uid_set_validity (base, seahorse_gpgme_convert_validity (userid->validity));
g_object_thaw_notify (obj);
}
static int check_dos_char_slowly(smb_ucs2_t c)
{
char buf[10];
smb_ucs2_t c2 = 0;
int len1, len2;
len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf),False);
if (len1 == 0) return 0;
len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2,False);
if (len2 != 2) return 0;
return (c == c2);
}
void SzbaseWrapper::remove_param(const std::string& base, const std::string& param)
throw( szbase_param_not_found_error , szbase_init_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
auto tparam = IPKContainer::GetObject()->GetParam( convert_string( base + ":" + param ), false );
if( tparam )
this->base->remove_param( tparam );
IPKContainer::GetObject()->RemoveExtraParam( convert_string ( base ) , convert_string( param ) );
}
std::string SzbaseWrapper::add_param( const std::string& param
, const std::string& base
, const std::string& formula
, const std::string& token
, const std::string& type
, int prec
, unsigned start_time)
throw( szbase_invalid_name , szbase_formula_invalid_syntax, szbase_init_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
std::wstring _param = convert_string( param );
std::wstring _token = convert_string( token );
std::wstring _formula = convert_string( formula );
std::wstring new_param_name;
if ( !create_param_name( _param , _token , new_param_name ) )
throw szbase_invalid_name(param + " in not valid user defined param name");
std::vector<std::wstring> strings;
if( !extract_strings_from_formula( _formula , strings ) )
throw szbase_formula_invalid_syntax("formula cannot be parsed");
for( auto& param : strings )
{
std::wstring new_name;
if ( !create_param_name_in_formula( param , _token , new_name ) )
continue;
auto i = _formula.find( param );
assert( i != std::wstring::npos );
_formula.replace( i , param.size() , new_name );
}
TParam::FormulaType formula_type;
if( type == "av" )
formula_type = TParam::LUA_AV;
else if( type == "va" )
formula_type = TParam::LUA_VA;
auto tparam = new TParam(NULL, NULL, L"", formula_type, TParam::P_LUA);
tparam->SetName(new_param_name);
tparam->SetPrec(prec);
tparam->SetTimeType(TParam::NANOSECOND); ///XXX:
tparam->SetLuaScript(SC::S2U(_formula).c_str());
tparam->SetLuaStartDateTime(start_time);
IPKContainer::GetObject()->AddExtraParam( convert_string ( base ) , tparam );
return reinterpret_cast<const char*>(SC::S2U(new_param_name).c_str());
}
SzbaseObserverToken SzbaseWrapper::register_observer( const std::string& param , std::function<void( void )> callback )
throw( szbase_init_error , szbase_param_not_found_error , szbase_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_param_not_found_error( "Param " + param + ", does not exist." );
return std::make_shared<SzbaseObserverImpl>( convert_string( base_name + ":" + param )
, IPKContainer::GetObject()
, base
, callback );
}
std::string SzbaseWrapper::get_data( const std::string& param ,
const std::string& from ,
const std::string& to ,
ValueType value_type ,
TimeType time_type ,
ProbeType pt ) const
throw( szbase_init_error, szbase_error )
{
std::ostringstream ss;
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_error( "Param " + param + ", does not exist." );
try {
switch (time_type) {
case TimeType::NANOSECOND:
::get_data<sz4::nanosecond_time_t>( base , tparam ,
from , to ,
value_type , pt.get_szarp_pt() ,
ss );
break;
case TimeType::SECOND:
::get_data<sz4::second_time_t> ( base , tparam ,
from , to ,
value_type , pt.get_szarp_pt() ,
ss );
break;
}
} catch ( sz4::exception& e ) {
throw szbase_error( "Cannot get data for param " + param + ": " + e.what() );
}
return ss.str();
}
std::string SzbaseWrapper::search_data( const std::string& param ,
const std::string& from ,
const std::string& to ,
TimeType time_type ,
SearchDir dir ,
ProbeType pt
) const
throw( szbase_init_error, szbase_error )
{
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_error( "Param " + param + ", does not exist." );
switch (time_type) {
case TimeType::NANOSECOND:
return search_data_helper<sz4::nanosecond_time_t>( base , tparam , from , to , dir , pt );
case TimeType::SECOND:
return search_data_helper<sz4::second_time_t> ( base , tparam , from , to , dir , pt );
}
/* NOT REACHED */
return std::string();
}
BOOL smbldap_get_single_attribute (LDAP * ldap_struct, LDAPMessage * entry,
const char *attribute, char *value,
int max_len)
{
char **values;
if ( !attribute )
return False;
value[0] = '\0';
if ((values = ldap_get_values (ldap_struct, entry, attribute)) == NULL) {
DEBUG (10, ("smbldap_get_single_attribute: [%s] = [<does not exist>]\n", attribute));
return False;
}
if (convert_string(CH_UTF8, CH_UNIX,values[0], -1, value, max_len, False) == (size_t)-1) {
DEBUG(1, ("smbldap_get_single_attribute: string conversion of [%s] = [%s] failed!\n",
attribute, values[0]));
ldap_value_free(values);
return False;
}
ldap_value_free(values);
#ifdef DEBUG_PASSWORDS
DEBUG (100, ("smbldap_get_single_attribute: [%s] = [%s]\n", attribute, value));
#endif
return True;
}
NTSTATUS ndr_push_charset(struct ndr_push *ndr, int ndr_flags, const char *var,
uint32_t length, uint8_t byte_mul, charset_t chset)
{
ssize_t ret, required;
if (NDR_BE(ndr) && chset == CH_UTF16) {
chset = CH_UTF16BE;
}
required = byte_mul * length;
NDR_PUSH_NEED_BYTES(ndr, required);
ret = convert_string(CH_UNIX, chset,
var, strlen(var),
ndr->data+ndr->offset, required, False);
if (ret == -1) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
}
/* Make sure the remaining part of the string is filled with zeroes */
if (ret < required) {
memset(ndr->data+ndr->offset+ret, 0, required-ret);
}
ndr->offset += required;
return NT_STATUS_OK;
}
unsigned char *get_text_translation(unsigned char *text, struct terminal *term)
{
unsigned char **current_tra;
struct conv_table *conv_table;
unsigned char *trn;
int ch = term ? term->spec->charset : 0;
if (is_direct_text(text)) return text;
if ((current_tra = translation_array[current_language][ch])) {
unsigned char *tt;
if ((trn = current_tra[text - dummyarray])) return trn;
tr:
if (!(tt = translations[current_language].t[text - dummyarray].name)) {
trn = stracpy(translation_english[text - dummyarray].name);
} else {
conv_table = get_translation_table(current_lang_charset, ch);
trn = convert_string(conv_table, tt, strlen(tt));
}
current_tra[text - dummyarray] = trn;
} else {
if (current_lang_charset && ch != current_lang_charset) {
current_tra = translation_array[current_language][ch] = mem_alloc(sizeof (unsigned char **) * T__N_TEXTS);
memset(current_tra, 0, sizeof (unsigned char **) * T__N_TEXTS);
goto tr;
}
if (!(trn = translations[current_language].t[text - dummyarray].name)) {
trn = translations[current_language].t[text - dummyarray].name = translation_english[text - dummyarray].name; /* modifying translation structure */
}
}
return trn;
}
Scanner::token_t Def::
extract_string_array (std::string *str,
std::wstring *wstr,
std::size_t nelems)
{
assert (0 != str);
assert (0 != wstr);
Scanner::token_t tok;
for (std::size_t i = 0; i != nelems; ++i) {
tok = scanner_.next_token ();
if (tok.token != Scanner::tok_string) {
issue_diag (W_MISSING, false, &tok, "expected string");
break;
}
str [i] = convert_string (tok.name);
wstr [i] = convert_wstring (tok);
}
return tok;
}
static int32_t constdb_load(FILE * file_stm, void * db_mem, int32_t db_size) {
const_t * db = (const_t *) db_mem;
int32_t cnt = DB_BEGIN;
char buf[BUF_SIZE];
char fld[BUF_SIZE];
int32_t read_buf = 0;
int32_t read_fld = 0;
int32_t data_fld = 0;
while(fgets(buf, BUF_SIZE, file_stm) != NULL) {
read_buf = 0;
read_fld = 0;
data_fld = 0;
while(1) {
/* check if delimiter for field */
if(isspace(buf[read_buf]) || buf[read_buf] == ',' || buf[read_buf] == '\0') {
fld[read_fld] = '\0';
switch(data_fld) {
case 0: db[cnt].name = convert_string(fld); break;
case 1:
/* constant can be represented as hexadecimal or decimal */
if(strlen(fld) > 2 && fld[0] == '0' && fld[1] == 'x')
db[cnt].value = convert_integer(fld, 16);
else
db[cnt].value = convert_integer(fld, 10);
break;
case 2: db[cnt].type = convert_integer(fld, 10); break;
default: fprintf(stdout,"warn: constdb_load; invalid field column %s in %s", fld, buf); break;
}
read_fld = 0;
data_fld++;
/* skip all other whitespace */
while(isspace(buf[read_buf+1]) && buf[read_buf+1] != '\0') read_buf++;
} else {
fld[read_fld] = buf[read_buf];
read_fld++;
}
/* finish reading the item */
if(buf[read_buf] == '\0' || buf[read_buf] == '\n') break;
read_buf++;
}
/* check for missing fields */
if(data_fld < CONST_COLUMNS_MIN || data_fld > CONST_COLUMNS_MAX)
fprintf(stdout,"warn: constdb_load; missing field expected %d < %d < %d %s",
CONST_COLUMNS_MIN, data_fld, CONST_COLUMNS_MAX, buf);
cnt++;
/* check for exceed size of allocated memory */
if(cnt > db_size) {
fprintf(stdout,"warn: constdb_load; exceeding the size of the database; %d < %d.\n%s\n", db_size, cnt, buf);
exit(EXIT_FAILURE);
}
}
return cnt;
}
double SzbaseWrapper::get_avg(
const std::string& param ,
time_t time ,
ProbeType type ) const
throw( szbase_init_error, szbase_get_value_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_get_value_error( "Cannot get value from param " + param + ", param not found" );
sz4::weighted_sum<double, unsigned> sum;
try {
base->get_weighted_sum( tparam ,
unsigned( time ) ,
unsigned( next( time , type , 1 ) ) ,
type.get_szarp_pt() ,
sum );
} catch( sz4::exception& e ) {
throw szbase_get_value_error( "Cannot get value from param " + param + ": " + e.what() );
}
return sz4::scale_value(sum.avg(), tparam);
}
// botsafe bprintf
void safe_bprintf (int printlevel, char *fmt, ...)
{
int i;
char bigbuffer[0x10000];
char bigbuffer2[0x10000];
int len;
va_list argptr;
edict_t *cl_ent;
va_start (argptr,fmt);
len = vsprintf (bigbuffer,fmt,argptr);
va_end (argptr);
if (dedicated->value)
{
convert_string(bigbuffer, 128, 255, -128, bigbuffer2); // green -> white
gi.cprintf(NULL, printlevel, bigbuffer2);
}
// This is to be compatible with Eraser (ACE)
//for (i=0; i<num_players; i++)
//{
// Ridah, changed this so CAM works
for (i=0 ; i<maxclients->value ; i++)
{
cl_ent = g_edicts + 1 + i;
if (cl_ent->inuse && !cl_ent->bot_client && cl_ent->client->pers.in_game)
if (G_EntExists(cl_ent))
gi.cprintf(cl_ent, printlevel, bigbuffer);
}
}
time_t SzbaseWrapper::get_latest(
const std::string& param ,
ProbeType type ) const
throw( szbase_init_error, szbase_get_value_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
bool ok;
std::wstring error;
/**
* It looks like szbase has different aruments for "search all" in
* case of 10sec and other probles
*/
time_t start = type == ProbeType( ProbeType::Type::LIVE ) ?
-1 :
std::numeric_limits<time_t>::max();
auto t = Szbase::GetObject()->Search(
convert_string( base_name + ":" + param ) ,
start , time_t(-1) , -1 ,
type.get_szarp_pt() , ok , error );
if( !ok )
throw szbase_get_value_error("Cannot get latest time of param " + param + ": " + SC::S2A(error) );
/**
* Round by hand because Szbase::Search returns probes rounded to
* either 10min or 10sec, not to exact pt
*/
return round( t , type );
}
std::string SzbaseWrapper::search_data( const std::string& param ,
const std::string& from ,
const std::string& to ,
TimeType time_type ,
SearchDir dir ,
ProbeType pt
) const
throw( szbase_init_error, szbase_param_not_found_error, szbase_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_param_not_found_error( "Param " + param + ", does not exist." );
std::string result;
switch (time_type) {
case TimeType::NANOSECOND:
result = search_data_helper<sz4::nanosecond_time_t>( base , tparam , from , to , dir , pt );
break;
case TimeType::SECOND:
result = search_data_helper<sz4::second_time_t> ( base , tparam , from , to , dir , pt );
break;
}
purge_cache();
return result;
}
time_t SzbaseWrapper::get_latest(
const std::string& param ,
ProbeType type ) const
throw( szbase_init_error, szbase_get_value_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_get_value_error( "Cannot get latest time of param " + param + ", param not found" );
unsigned t;
try {
base->get_last_time( tparam, t );
} catch( sz4::exception& e) {
throw szbase_get_value_error( "Cannot get latest time of param " + param + ": " + e.what() );
}
/**
* Round by hand because search returns probes rounded to
* either 10min or 10sec, not to exact pt
*/
return t == unsigned( -1 ) ? -1 : round( t , type );
}
void html_form_control(struct part *p, struct form_control *fc)
{
if (!p->data) {
/*destroy_fc(fc);
mem_free(fc);*/
add_to_list(p->uf, fc);
return;
}
fc->g_ctrl_num = g_ctrl_num++;
if (fc->type == FC_TEXT || fc->type == FC_PASSWORD || fc->type == FC_TEXTAREA) {
unsigned char *dv = convert_string(convert_table, fc->default_value, strlen(fc->default_value));
if (dv) {
mem_free(fc->default_value);
fc->default_value = dv;
}
/*
for (i = 0; i < fc->nvalues; i++) if ((dv = convert_string(convert_table, fc->values[i], strlen(fc->values[i])))) {
mem_free(fc->values[i]);
fc->values[i] = dv;
}
*/
}
if (fc->type == FC_TEXTAREA) {
unsigned char *p;
for (p = fc->default_value; p[0]; p++) if (p[0] == '\r') {
if (p[1] == '\n') memmove(p, p + 1, strlen(p)), p--;
else p[0] = '\n';
}
}
add_to_list(p->data->forms, fc);
}
static void
render_rss_item(struct dom_renderer *renderer, struct dom_node *item)
{
struct rss_renderer *rss = renderer->data;
struct dom_string *title = get_rss_text(item, RSS_ELEMENT_TITLE);
struct dom_string *link = get_rss_text(item, RSS_ELEMENT_LINK);
struct dom_string *author = get_rss_text(item, RSS_ELEMENT_AUTHOR);
struct dom_string *date = get_rss_text(item, RSS_ELEMENT_PUBDATE);
if (item->data.element.type == RSS_ELEMENT_ITEM) {
Y(renderer)++;
X(renderer) = 0;
}
if (title && is_dom_string_set(title)) {
if (item->data.element.type == RSS_ELEMENT_CHANNEL) {
unsigned char *str;
str = convert_string(renderer->convert_table,
title->string, title->length,
renderer->document->options.cp,
CSM_DEFAULT, NULL, NULL, NULL);
if (str)
renderer->document->title = str;
}
render_dom_text(renderer, &rss->styles[RSS_STYLE_TITLE],
title->string, title->length);
}
if (link && is_dom_string_set(link)) {
X(renderer)++;
add_dom_link(renderer, "[link]", 6, link->string, link->length);
}
/* New line, and indent */
Y(renderer)++;
X(renderer) = 0;
if (author && is_dom_string_set(author)) {
render_dom_text(renderer, &rss->styles[RSS_STYLE_AUTHOR],
author->string, author->length);
}
if (date && is_dom_string_set(date)) {
if (author && is_dom_string_set(author)) {
render_dom_text(renderer, &rss->styles[RSS_STYLE_AUTHOR_DATE_SEP],
" - ", 3);
}
render_dom_text(renderer, &rss->styles[RSS_STYLE_DATE],
date->string, date->length);
}
if ((author && is_dom_string_set(author))
|| (date && is_dom_string_set(date))) {
/* New line, and indent */
Y(renderer)++;
X(renderer) = 0;
}
}
int check_unicode_conversion( const string_t *str_a, const string_t *str_w, int codepage )
{
int ok;
string_t *teststr = convert_string( str_w, str_char, codepage );
ok = (teststr->size == str_a->size && !memcmp( teststr->str.cstr, str_a->str.cstr, str_a->size ));
if (!ok)
{
int i;
fprintf( stderr, "Source: %s", str_a->str.cstr );
for (i = 0; i < str_a->size; i++)
fprintf( stderr, " %02x", (unsigned char)str_a->str.cstr[i] );
fprintf( stderr, "\nUnicode: " );
for (i = 0; i < str_w->size; i++)
fprintf( stderr, " %04x", str_w->str.wstr[i] );
fprintf( stderr, "\nBack: %s", teststr->str.cstr );
for (i = 0; i < teststr->size; i++)
fprintf( stderr, " %02x", (unsigned char)teststr->str.cstr[i] );
fprintf( stderr, "\n" );
}
free_string( teststr );
return ok;
}
/**
* Copy a string from a dos codepage source to a unix char* destination.
*
* The resulting string in "dest" is always null terminated.
*
* @param flags can have:
* <dl>
* <dt>STR_TERMINATE</dt>
* <dd>STR_TERMINATE means the string in @p src
* is null terminated, and src_len is ignored.</dd>
* </dl>
*
* @param src_len is the length of the source area in bytes.
* @returns the number of bytes occupied by the string in @p src.
**/
size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
{
size_t ret;
if (dest_len == (size_t)-1)
dest_len = sizeof(pstring);
if (flags & STR_TERMINATE) {
if (src_len == (size_t)-1) {
src_len = strlen((const char *)src) + 1;
} else {
size_t len = strnlen((const char *)src, src_len);
if (len < src_len)
len++;
src_len = len;
}
}
ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
if (ret == (size_t)-1) {
ret = 0;
dest_len = 0;
}
if (dest_len && ret) {
/* Did we already process the terminating zero ? */
if (dest[MIN(ret-1, dest_len-1)] != 0) {
dest[MIN(ret, dest_len-1)] = 0;
}
} else {
dest[0] = 0;
}
return src_len;
}
// ---------------------------------------------------------------------------
//
// ------------
int bXMapSHPExport::obj_dump(void *o, void *prm) {
_bTrace_("bXMapSHPExport::obj_dump",false);
bGenericGeoElement* go=(bGenericGeoElement*)o;
extype* et=(extype*)prm;
ivertices* vxs;
int k=et->shp->CountRecords()+1;
fieldindex fx;
#if __str_conversion__==1
int kd;
#endif
go->getVertices(&vxs);
if(et->shp->WriteVal(k,kOBJ_Vertices_,&vxs)) {
}
for(int i=1; i<=et->flds->count(); i++) {
et->flds->get(i,&fx);
if(!go->getValue(fx.bidx,fx.val)) {
_te_("go->getValue "+fx.bidx);
}
#if __str_conversion__==1
et->dbf->FieldSign(fx.didx,&kd);
if(kd==_char) {
convert_string((char*)fx.val);
_tm_((char*)fx.val);
}
#endif
if(et->dbf->WriteVal(k,fx.didx,fx.val)) {
if(fx.didx==1) {
//_tm_("len=%d;%s",strlen((char*)fx.val),(char*)fx.val);
}
//_te_("dbf->WriteVal %d;%d",fx.didx,fx.bidx);
}
}
return(0);
}
size_t push_ascii_nstring(void *dest, const char *src)
{
size_t i, buffer_len, dest_len;
smb_ucs2_t *buffer;
conv_silent = True;
buffer_len = push_ucs2_allocate(&buffer, src);
if (buffer_len == (size_t)-1) {
smb_panic("failed to create UCS2 buffer");
}
/* We're using buffer_len below to count ucs2 characters, not bytes. */
buffer_len /= sizeof(smb_ucs2_t);
dest_len = 0;
for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
unsigned char mb[10];
/* Convert one smb_ucs2_t character at a time. */
size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
memcpy((char *)dest + dest_len, mb, mb_len);
dest_len += mb_len;
} else {
errno = E2BIG;
break;
}
}
((char *)dest)[dest_len] = '\0';
SAFE_FREE(buffer);
conv_silent = False;
return dest_len;
}
/**
* Copy a string from a char* unix src to a dos codepage string destination.
*
* @return the number of bytes occupied by the string in the destination.
*
* @param flags can include
* <dl>
* <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
* <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
* </dl>
*
* @param dest_len the maximum length in bytes allowed in the
* destination. If @p dest_len is -1 then no maximum is used.
**/
size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
{
size_t src_len = strlen(src);
pstring tmpbuf;
size_t ret;
/* No longer allow a length of -1 */
if (dest_len == (size_t)-1)
smb_panic("push_ascii - dest_len == -1");
if (flags & STR_UPPER) {
pstrcpy(tmpbuf, src);
strupper_m(tmpbuf);
src = tmpbuf;
}
if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
src_len++;
ret =convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
if (ret == (size_t)-1 &&
(flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
&& dest_len > 0) {
((char *)dest)[0] = '\0';
}
return ret;
}
int d_vfprintf(FILE *f, const char *format, va_list ap)
{
char *p = NULL, *p2 = NULL;
int ret, maxlen, clen;
const char *msgstr;
va_list ap2;
va_copy(ap2, ap);
/* do any message translations */
msgstr = lang_msg(format);
if (!msgstr) {
ret = -1;
goto out;
}
ret = vasprintf(&p, msgstr, ap2);
lang_msg_free(msgstr);
if (ret <= 0) {
ret = -1;
goto out;
}
/* now we have the string in unix format, convert it to the display
charset, but beware of it growing */
maxlen = ret*2;
again:
p2 = (char *)SMB_MALLOC(maxlen);
if (!p2) {
ret = -1;
goto out;
}
clen = convert_string(CH_UNIX, CH_DISPLAY, p, ret, p2, maxlen, True);
if (clen == -1) {
ret = -1;
goto out;
}
if (clen >= maxlen) {
/* it didn't fit - try a larger buffer */
maxlen *= 2;
SAFE_FREE(p2);
goto again;
}
/* good, its converted OK */
ret = fwrite(p2, 1, clen, f);
out:
SAFE_FREE(p);
SAFE_FREE(p2);
va_end(ap2);
return ret;
}
SzbaseObserverToken SzbaseWrapper::register_observer( const std::string& param , std::function<void( void )> callback )
throw( szbase_init_error, szbase_error )
{
TParam* tparam = IPKContainer::GetObject()->GetParam( convert_string( base_name + ":" + param ) );
if( !tparam )
throw szbase_error( "Cannot register observer for param " + param + ", param not found" );
return std::make_shared<SzbaseObserverImpl>( tparam , base , callback );
}
