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);
}

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();
}

 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;
}

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;
}

// 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 );
}

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;
}