char SeniorVMHandle::pop_operand( pVOperand o )
{
if (o == NULL)
{
return 0;
}
if (o->is_mem( ))
{
r_get_mem( o->_mem.base,o->_mem.index,o->_mem.scale,o->_mem.lval );
switch (o->_mem.size )
{
case 1:
db( GET_HANDLE( b_write_mem ) );
return 1;
break;
case 2:
db( GET_HANDLE( w_write_mem ) );
return 2;
break;
case 4:
db( GET_HANDLE( d_write_mem ) );
return 4;
break;
#ifdef PROTECT_X64
case 8:
db( GET_HANDLE( q_write_mem ) );
return 8;
break;
#endif
}
} else if (o->is_reg( ))
{
pop( o->_reg.base );
if (o->_reg.base & T_E32X)
{
return 4;
} else if (o->_reg.base & T_16X)
{
return 2;
} else if ( o->_reg.base & T_8L || o->_reg.base & T_8H)
{
return 1;
} else
return 8;
} else if (o->is_none( ))
{
return 0;
}
else {
cout << "未知操作数\r\n" << endl;
throw;
return -1;
}
return 0;
}
krb5_error_code
krb5_ldap_delete_krbcontainer(krb5_context context, const char *dn)
{
LDAP *ld=NULL;
krb5_error_code st=0;
kdb5_dal_handle *dal_handle=NULL;
krb5_ldap_context *ldap_context=NULL;
krb5_ldap_server_handle *ldap_server_handle=NULL;
SETUP_CONTEXT ();
/* get ldap handle */
GET_HANDLE ();
if (dn == NULL) {
st = EINVAL;
k5_setmsg(context, st, _("Kerberos Container information is missing"));
goto cleanup;
}
/* delete the kerberos container */
if ((st = ldap_delete_ext_s(ld, dn, NULL, NULL)) != LDAP_SUCCESS) {
int ost = st;
st = translate_ldap_error (st, OP_ADD);
k5_setmsg(context, st, _("Kerberos Container delete FAILED: %s"),
ldap_err2string(ost));
goto cleanup;
}
cleanup:
krb5_ldap_put_handle_to_pool(ldap_context, ldap_server_handle);
return(st);
}
int VPLHttp2__Impl::Put(const std::string &reqBodyFilePath,
VPLHttp2_ProgressCb sendProgCb,
void *sendProgCtx,
std::string &respBody)
{
int rv = 0;
GET_HANDLE(&(this->mutex), this->handleInUse);
setMethod(PUT);
rv = sendFromFile(reqBodyFilePath);
if (rv == 0) {
rv = setupProgressCallback(sendProgCb, sendProgCtx);
}
if (rv == 0) {
rv = recvToString(respBody);
}
if (rv == 0) {
rv = connect();
}
PUT_HANDLE(&(this->mutex), this->handleInUse);
return rv;
}
static RobWidget* m2_mouseup(RobWidget* handle, RobTkBtnEvent *event) {
MF2UI* ui = (MF2UI*)GET_HANDLE(handle);
ui->drag_cutoff_x = -1;
ui->update_annotations = true;
queue_draw(ui->m2);
return NULL;
}
int VPLHttp2__Impl::Post(VPLHttp2_SendCb sendCb,
void *sendCtx, u64 sendSize,
VPLHttp2_ProgressCb sendProgCb,
void *sendProgCtx,
std::string &respBody)
{
int rv = 0;
GET_HANDLE(&(this->mutex), this->handleInUse);
setMethod(POST);
rv = sendFromCallback(sendCb, sendCtx, sendSize);
if (rv == 0) {
rv = setupProgressCallback(sendProgCb, sendProgCtx);
}
if (rv == 0) {
rv = recvToString(respBody);
}
if (rv == 0) {
rv = connect();
}
PUT_HANDLE(&(this->mutex), this->handleInUse);
return rv;
}
int VPLHttp2__Impl::Post(const std::string &reqBody,
VPLHttp2_RecvCb recvCb,
void *recvCtx,
VPLHttp2_ProgressCb recvProgCb,
void *recvProgCtx)
{
int rv = 0;
GET_HANDLE(&(this->mutex), this->handleInUse);
setMethod(POST);
rv = sendFromString(reqBody);
if( rv == 0) {
rv = recvToCallback(recvCb, recvCtx);
}
if (rv == 0) {
rv = setupProgressCallback(recvProgCb, recvProgCtx);
}
if (rv == 0) {
rv = connect();
}
PUT_HANDLE(&(this->mutex), this->handleInUse);
return rv;
}
JNIEXPORT jobject JNICALL Java_org_a11y_BrlAPI_Native_getDisplaySize(JNIEnv *jenv, jobject jobj) {
unsigned int x, y;
jclass jcsize;
jmethodID jinit;
jobject jsize;
GET_HANDLE(jenv, jobj, NULL);
env = jenv;
if (brlapi__getDisplaySize(handle, &x, &y) < 0) {
ThrowError(jenv, __func__);
return NULL;
}
if (!(jcsize = (*jenv)->FindClass(jenv, "org/a11y/BrlAPI/DisplaySize"))) {
ThrowException(jenv, ERR_NULLPTR, __func__);
return NULL;
}
if (!(jinit = (*jenv)->GetMethodID(jenv, jcsize, "<init>", "(II)V"))) {
ThrowException(jenv, ERR_NULLPTR, __func__);
return NULL;
}
if (!(jsize = (*jenv)->NewObject(jenv, jcsize, jinit, x, y))) {
ThrowException(jenv, ERR_NULLPTR, __func__);
return NULL;
}
return jsize;
}
JNIEXPORT jint JNICALL Java_org_a11y_BrlAPI_Native_enterTtyMode(JNIEnv *jenv, jobject jobj, jint jtty, jstring jdriver) {
int tty ;
char *driver;
int result;
GET_HANDLE(jenv, jobj, -1);
env = jenv;
tty = (int)jtty;
if (!jdriver)
driver = NULL;
else
if (!(driver = (char *)(*jenv)->GetStringUTFChars(jenv, jdriver, NULL))) {
ThrowException(jenv, ERR_OUTOFMEM, __func__);
return -1;
}
result = brlapi__enterTtyMode(handle, tty,driver);
if (result < 0) {
ThrowError(jenv, __func__);
return -1;
}
return (jint) result;
}
void SeniorVMHandle::q_not_and(long _register1,long _register2,bool is_data)
{
if (is_data)
{
q_push_imm( _register2 );
push( _register1 );
db( GET_HANDLE( q_nand ) );
return;
}
if (_register1 == 0 || _register2 == 0)
{
db(HANDLE.q_nand.handle);
return;
}
push(_register2,false);
//db(HANDLE.push_esp.handle);
//db(HANDLE.q_read_mem.handle);
//pop(_register2);
push(_register1,false);
//db(HANDLE.push_esp.handle);
//db(HANDLE.q_read_mem.handle);
//pop(_register1);
db(HANDLE.q_nand.handle);
}
static void native_compile(JNIEnv* env, jobject object, jstring sqlString)
{
char buf[65];
strcpy(buf, "android_database_SQLiteProgram->native_compile() not implemented");
throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
return;
}
static void native_finalize(JNIEnv* env, jobject object)
{
char buf[66];
strcpy(buf, "com_sqlcrypt_database_SQLiteProgram->native_finalize() not implemented");
throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
return;
}
krb5_error_code
krb5_ldap_create_krbcontainer(krb5_context context, const char *dn)
{
LDAP *ld=NULL;
char *strval[2]={NULL}, **rdns=NULL;
LDAPMod **mods = NULL;
krb5_error_code st=0;
kdb5_dal_handle *dal_handle=NULL;
krb5_ldap_context *ldap_context=NULL;
krb5_ldap_server_handle *ldap_server_handle=NULL;
SETUP_CONTEXT ();
/* get ldap handle */
GET_HANDLE ();
if (dn == NULL) {
st = EINVAL;
k5_setmsg(context, st, _("Kerberos Container information is missing"));
goto cleanup;
}
strval[0] = "krbContainer";
strval[1] = NULL;
if ((st=krb5_add_str_mem_ldap_mod(&mods, "objectclass", LDAP_MOD_ADD, strval)) != 0)
goto cleanup;
rdns = ldap_explode_dn(dn, 1);
if (rdns == NULL) {
st = EINVAL;
k5_setmsg(context, st, _("Invalid Kerberos container DN"));
goto cleanup;
}
strval[0] = rdns[0];
strval[1] = NULL;
if ((st=krb5_add_str_mem_ldap_mod(&mods, "cn", LDAP_MOD_ADD, strval)) != 0)
goto cleanup;
/* create the kerberos container */
st = ldap_add_ext_s(ld, dn, mods, NULL, NULL);
if (st == LDAP_ALREADY_EXISTS)
st = LDAP_SUCCESS;
if (st != LDAP_SUCCESS) {
int ost = st;
st = translate_ldap_error (st, OP_ADD);
k5_setmsg(context, st, _("Kerberos Container create FAILED: %s"),
ldap_err2string(ost));
goto cleanup;
}
cleanup:
if (rdns)
ldap_value_free (rdns);
ldap_mods_free(mods, 1);
krb5_ldap_put_handle_to_pool(ldap_context, ldap_server_handle);
return(st);
}
static void m2_leave(RobWidget *handle) {
MF2UI* ui = (MF2UI*)GET_HANDLE(handle);
if (ui->prelight_cutoff) {
ui->prelight_cutoff = false;
ui->update_annotations = true;
queue_draw(ui->m2);
}
}
void SeniorVMHandle::set_key( long _key )
{
//recover_vm_context();
#ifndef PROTECT_X64
d_push_imm( _key );
#else
q_push_imm( _key );
#endif
db( GET_HANDLE( set_key ) );
}
static void
m0_size_allocate (RobWidget* rw, int w, int h) {
BITui* ui = (BITui*)GET_HANDLE(rw);
robwidget_set_size (rw, w, h);
if (ui->m0_faceplate) {
cairo_surface_destroy (ui->m0_faceplate);
ui->m0_faceplate = NULL;
}
queue_draw (rw);
}
static void native_clear_bindings(JNIEnv* env, jobject object)
{
int err;
sqlite3_stmt * statement = GET_STATEMENT(env, object);
err = sqlite3_clear_bindings(statement);
if (err != SQLITE_OK) {
throw_sqlite3_exception(env, GET_HANDLE(env, object));
return;
}
}
bool WeCacheServer::OnPacket(TCPSession *session, uint32_t cmd, const char *packet_data, uint32_t head_size, uint32_t body_size, uint64_t tid)
{
if(!HAS_HANDLE(cmd))
{
LOG_DEBUG(logger, "can't find handler for cmd="<<cmd<<".fd="<<session->GetFD());
//由父类来处理
return TCPServer::OnPacket(session, cmd, packet_data, head_size, body_size, tid);
}
HANDLER_PTR handler = GET_HANDLE(cmd);
int ret = (this->*handler)(session, packet_data, head_size, body_size, tid);
return ret==0?true:false;
}
static void native_bind_double(JNIEnv* env, jobject object,
jint index, jdouble value)
{
int err;
sqlite3_stmt * statement = GET_STATEMENT(env, object);
err = sqlite3_bind_double(statement, index, value);
if (err != SQLITE_OK) {
char buf[32];
sprintf(buf, "handle %p", statement);
throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);
return;
}
}
JNIEXPORT jstring JNICALL Java_org_a11y_BrlAPI_Native_getDriverName(JNIEnv *jenv, jobject jobj) {
char name[32];
GET_HANDLE(jenv, jobj, NULL);
env = jenv;
if (brlapi__getDriverName(handle, name, sizeof(name)) < 0) {
ThrowError(jenv, __func__);
return NULL;
}
name[sizeof(name)-1] = 0;
return (*jenv)->NewStringUTF(jenv, name);
}
static void
m0_set_scaling(RobWidget* rw, int w, int h) {
MF2UI* ui = (MF2UI*)GET_HANDLE(rw);
const float dflw = 2 * (PH_RAD + YOFF);
const float dflh = 2 * (PH_RAD + YOFF);
float scale = MIN(w/dflw, h/dflh);
if (scale != ui->scale || (int)ui->m0_width != h || (int)ui->m0_height != h) {
ui->m0_width = w;
ui->m0_height = h;
ui->scale = scale;
ui->pscale = sqrtf(scale);
ui->update_grid = true;
}
queue_draw(rw);
}
void mutex_print(pthread_mutex_t *m, char *txt)
{
if (!print_state) return;
mutex_t *m_ = (mutex_t *)*m;
if (m_ == NULL) {
printf("M%p %d %s\n",*m,(int)GetCurrentThreadId(),txt);
} else {
printf("M%p %d V=%0X B=%d t=%d o=%d C=%d R=%d H=%p %s\n",
*m,
(int)GetCurrentThreadId(),
(int)m_->valid,
(int)m_->busy,
m_->type,
(int)GET_OWNER(m_),(int)(m_->count),(int)GET_RCNT(m_),GET_HANDLE(m_),txt);
}
}
/* level range scale */
static bool ga_expose_event(RobWidget* handle, cairo_t* cr, cairo_rectangle_t *ev) {
MF2UI* ui = (MF2UI*)GET_HANDLE(handle);
if (ui->update_annotations) {
update_annotations(ui);
ui->update_annotations = false;
}
cairo_rectangle (cr, ev->x, ev->y, ev->width, ev->height);
cairo_clip (cr);
cairo_set_source_surface(cr, ui->sf_gain, 0, 0);
cairo_paint (cr);
return TRUE;
}
static RobWidget* m2_mousemove(RobWidget* handle, RobTkBtnEvent *event) {
MF2UI* ui = (MF2UI*)GET_HANDLE(handle);
if (ui->drag_cutoff_x < 0) return NULL;
const float mxw = -MIN_CUTOFF / (float) (ANN_W - XOFF * 2 - 36);
const float diff = (event->x - ui->drag_cutoff_x) * mxw;
float cutoff = ui->drag_cutoff_db + diff;
if (cutoff <= MIN_CUTOFF) cutoff = MIN_CUTOFF;
if (cutoff >= -10) cutoff = -10;
if (ui->db_cutoff != cutoff) {
ui->db_cutoff = cutoff;
ui->update_annotations = true;
queue_draw(ui->m2);
ui->write(ui->controller, MF_CUTOFF, sizeof(float), 0, (const void*) &cutoff);
}
return handle;
}
int VPLHttp2__Impl::Get(std::string &respBody)
{
int rv = 0;
GET_HANDLE(&(this->mutex), this->handleInUse);
setMethod(GET);
rv = recvToString(respBody);
if (rv == 0) {
rv = connect();
}
PUT_HANDLE(&(this->mutex), this->handleInUse);
return rv;
}
JNIEXPORT jlong JNICALL Java_org_a11y_BrlAPI_Native_readKey(JNIEnv *jenv, jobject jobj, jboolean jblock) {
brlapi_keyCode_t code;
int result;
GET_HANDLE(jenv, jobj, -1);
env = jenv;
result = brlapi__readKey(handle, (int) jblock, &code);
if (result < 0) {
ThrowError(jenv, __func__);
return -1;
}
if (!result) return (jlong)(-1);
return (jlong)code;
}
void SeniorVMHandle::b_and(long _register1,long _register2,bool is_data) //如果is_data为真 那register2为数据
{
if (is_data)
{
b_not( _register2 , true );
pop( T_INVALID );
b_not( _register1 );
pop( T_INVALID );
db( GET_HANDLE( b_nand ) );
return;
}
b_not(_register2);
pop(T_INVALID);
b_not(_register1);
pop(T_INVALID);
db(HANDLE.b_nand.handle);
}
void SeniorVMHandle::q_and(long _register1,long _register2,bool is_data)
{
if (is_data)
{
q_not( _register2 , true );
pop( T_INVALID );
q_not( _register1 );
pop( T_INVALID );
db( GET_HANDLE( q_nand ) );
return;
}
q_not(_register2);
pop(T_INVALID);
q_not(_register1);
pop(T_INVALID);
db(HANDLE.q_nand.handle);
}
static RobWidget* m2_mousedown(RobWidget* handle, RobTkBtnEvent *event) {
MF2UI* ui = (MF2UI*)GET_HANDLE(handle);
if (event->state & ROBTK_MOD_SHIFT) {
ui->db_cutoff = -45;
ui->update_annotations = true;
queue_draw(ui->m2);
return NULL;
}
ui->drag_cutoff_db = ui->db_cutoff;
ui->drag_cutoff_x = event->x;
ui->update_annotations = true;
queue_draw(ui->m2);
return handle;
}
void SeniorVMHandle::w_not_and(long _register1,long _register2,bool is_data)
{
if (is_data)
{
w_push_imm( _register2 );
push( _register1 );
db( GET_HANDLE( w_nand ) );
return;
}
if (_register1 == 0 || _register2 == 0)
{
db(HANDLE.w_nand.handle);
return;
}
push(_register2);
push(_register1);
db(HANDLE.w_nand.handle);
}
void SeniorVMHandle::b_not(long _register,bool is_data)
{
if (is_data)
{
b_push_imm( _register );
b_copy_stack();
db( GET_HANDLE( b_nand ) );
}
if (_register == 0)
{
db(HANDLE.b_nand.handle);
return;
}
push(_register);
db(HANDLE.push_stack_top_base.handle);
db(HANDLE.b_read_mem.handle);
db(HANDLE.b_nand.handle);
}
