static void
timer_handler(void *data) {
qltimer_t *timer;
lua_State *state;
timer = (qltimer_t*)data;
state = timer->state;
/* actor just sleep? */
if (qstring_empty(timer->mod)) {
qdict_del_num(timer->actor->timers, timer->id);
lua_resume(state, 0);
return;
}
lua_getglobal(state, timer->mod);
if (!lua_istable(state, -1)) {
qerror("mod %s is not exist", timer->mod);
qtimer_del(timer->engine, timer->id);
return;
}
lua_getfield(state, -1, timer->func);
if (!lua_isfunction(state, -1)) {
qerror("%s.%s is not lua function", timer->mod, timer->func);
qtimer_del(timer->engine, timer->id);
return;
}
lua_pcall(state, 0, LUA_MULTRET, 0);
}
//=========================================
// Constructor
//-----------------------------------------
SSLClient::SSLClient ( QObject* parent ) : SSLCommon ( parent ) {
BIO *sbio = NULL;
printf ("Initialize openssl\n");
init_OpenSSL ();
seed_prng ();
printf ("Setup client context\n");
setupClientCTX ();
printf ("Connecting TCP socket\n");
connectTCP ();
printf ("Creating new SSL object\n");
ssl = SSL_new (ctx);
printf ("Creating new SSL BIO socket: %d\n",mSocket);
sbio= BIO_new_socket (mSocket,BIO_NOCLOSE);
printf ("Setup SSL BIO socket\n");
SSL_set_bio (ssl,sbio,sbio);
printf ("Connecting SSL socket\n");
if (SSL_connect(ssl) <=0) {
qerror ("Error creating connection BIO");
}
int ofcmode = fcntl (mSocket,F_GETFL,0);
if (fcntl (mSocket,F_SETFL,ofcmode | O_NDELAY)) {
qerror ("Couldn't make socket nonblocking");
}
FD_ZERO (&readFDs);
printf ("SSL Connection created\n");
}
//=========================================
// setupClientCTX
//-----------------------------------------
void SSLClient::setupClientCTX (void) {
ctx = SSL_CTX_new(SSLv23_method( ));
SSL_CTX_set_default_passwd_cb (ctx, passwd_cb);
OpenSSL_add_all_algorithms();
if (SSL_CTX_load_verify_locations(
ctx, CAFILE.toLatin1().data(), CADIR) != 1
) {
qerror("Error loading CA file and/or directory");
}
if (SSL_CTX_set_default_verify_paths(ctx) != 1) {
qerror("Error loading default CA file and/or directory");
}
if (SSL_CTX_use_certificate_chain_file(
ctx, CLIENT_CERTFILE.toLatin1().data()) != 1
) {
qerror("Error loading certificate from file");
}
if (SSL_CTX_use_PrivateKey_file(
ctx,CLIENT_CERTFILE.toLatin1().data(),SSL_FILETYPE_PEM
) != 1) {
qerror("Error loading private key from file");
}
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
SSL_CTX_set_verify_depth(ctx, 4);
SSL_CTX_set_options(ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2);
if (SSL_CTX_set_cipher_list(ctx, CIPHER_LIST) != 1) {
qerror("Error setting cipher list (no valid ciphers)");
}
}
//=========================================
// connectTCP
//-----------------------------------------
void SSLClient::connectTCP (void) {
QString port;
QTextStream (&port) << serverPort;
struct addrinfo hints;
struct addrinfo *res=NULL;
struct addrinfo *rp=NULL;
int err;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family=AF_UNSPEC;
hints.ai_socktype=SOCK_STREAM;
hints.ai_flags = 0;
hints.ai_protocol=0;
err = getaddrinfo (
serverName.toLatin1().data(), port.toLatin1().data(), &hints, &res
);
if (err != 0) {
qerror ("Couldn't resolve host");
}
for (rp = res; rp != NULL; rp = rp->ai_next) {
mSocket = socket(rp->ai_family,rp->ai_socktype,rp->ai_protocol);
if (mSocket == -1) {
continue;
}
if (::connect(mSocket,rp->ai_addr,rp->ai_addrlen) != -1) {
break; // success
}
close(mSocket);
}
if (rp == NULL) {
qerror ("Couldn't connect host");
}
}
void netStruct_init()
{
int iterator;
unsigned int* def;
symbolType s;
buffers=getVarNumber(TOTALBUFFERNUM);
bufferLen=getVarNumber(TOTALBUFFERLEN);
def=getvar(BASICBUFFERSTS ,&s);
if(def&&symbolType_string==s)
{
defaultStatus=*def;
}
ns=malloc(sizeof(netStruct)*buffers);
shares=malloc(sizeof(netStruct*)*buffers);
if(!shares||!ns)
qerror("Failed allocation of netstruct buffers",0);
for(iterator=0;iterator<buffers;iterator++)
{
ns[iterator].data=malloc(bufferLen);
if(!ns[iterator].data)
qerror("failed allocating memory for buffer",0);
shares[iterator]=ns+iterator;
}
}
int set_nonblocking(int fd) {
int flags;
if ((flags = fcntl(fd, F_GETFL)) == -1) {
qerror("fcntl(F_GETFL): %s", strerror(errno));
return -1;
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
qerror("fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
return -1;
}
return 0;
}
int
qnet_tcp_connect(int port, const char *addr, int *error, int *fd) {
struct sockaddr_in dstaddr;
socklen_t len;
if ((*fd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
*error = errno;
qerror("create socket error: %s", strerror(errno));
return QERROR;
}
if (set_nonblocking(*fd) < 0) {
*error = errno;
return QERROR;
}
dstaddr.sin_family = AF_INET;
dstaddr.sin_port = htons(port);
if (inet_aton(addr, &dstaddr.sin_addr) == 0) {
qerror("invalid bind address");
*error = errno;
close(*fd);
return QERROR;
}
len = sizeof(dstaddr);
while (1) {
if (connect(*fd, (struct sockaddr*)(&dstaddr), len) == -1) {
if (errno == EINTR) {
continue;
}
if (errno == EINPROGRESS) {
*error = errno;
return QNONBLOCKING;
}
if (errno == EISCONN) {
return QOK;
}
qerror("connect to %s:%d error: %s", addr, port, strerror(errno));
close(*fd);
return QERROR;
}
break;
}
return QOK;
}
static int net_listen(int fd, struct sockaddr *sa, socklen_t len) {
if (bind(fd, sa, len) < 0) {
qerror("bind error: %s", strerror(errno));
close(fd);
return -1;
}
if (listen(fd, 511) == -1) {
qerror("listen: %s", strerror(errno));
close(fd);
return -1;
}
return 0;
}
static int
set_nonblocking(int fd) {
int flags;
if ((flags = fcntl(fd, F_GETFL)) == -1) {
qerror("fcntl(F_GETFL) error: %s", strerror(errno));
return QERROR;
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
qerror("fcntl(F_SETFL,O_NONBLOCK) error: %s", strerror(errno));
return QERROR;
}
return QOK;
}
static int
worker_start_handler(qmsg_t *msg, void *reader) {
qwmsg_start_t *start;
qworker_t *worker;
int ret;
qid_t aid;
qactor_t *actor;
lua_State *state;
qinfo("handle start msg");
worker = (qworker_t*)reader;
start = (qwmsg_start_t*)msg;
aid = start->aid;
actor = qactor_new(aid);
if (actor == NULL) {
qerror("new actor: %d error", aid);
return QERROR;
}
qassert(actor->state == NULL);
qactor_attach(actor, qlua_new_thread(worker, &actor->ref));
actor->tid = worker->tid;
if (qlua_threadloadfile(actor, actor->state, config.main) != 0) {
qerror("load server start script %s error", config.main);
return QERROR;
}
state = actor->state;
lua_getglobal(state, "server");
if (lua_isnil(state, -1)) {
qerror("load server script server table error");
return QERROR;
}
lua_getfield(state, -1, "start");
if (lua_isnil(state, -1)) {
qerror("load server script server.start func error");
return QERROR;
}
if (qlua_call(state, 0, 0) == 0) {
ret = (int)lua_tonumber(state, -1);
lua_pop(state, 1 );
} else {
qlua_fail(state);
}
return ret;
}
int qnet_tcp_listen(int port, const char *bindaddr) {
UNUSED(bindaddr);
int fd;
struct sockaddr_in sa;
if ((fd = create_socket()) < 0) {
return -1;
}
if (set_nonblocking(fd) < 0) {
return -1;
}
memset(&sa,0,sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
qerror("invalid bind address");
close(fd);
return -1;
}
if (net_listen(fd,(struct sockaddr*)&sa, sizeof(sa)) < 0) {
close(fd);
return -1;
}
return fd;
}
static int create_socket() {
int fd, on;
on = 1;
if ((fd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
qerror("creating socket: %s", strerror(errno));
return -1;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
qerror("setsockopt SO_REUSEADDR: %s", strerror(errno));
return -1;
}
return fd;
}
int main(int argc,char** argv) {
init(argc,argv);
putMessageSize((uint8_t*)"ERROR!",0);
qNexus* q=qNexus_top();
char* name;
while((name=get_option(frames)))
{
FILE* a=fopen(name,"r");
if(!a)
{
RETHPORT(name);
qerror("No such File",0);
}
netStruct* on=netStruct_get();
on->length=fread(on->data,1,netStruct_getBufferLen(),a);
qNexus_enqueue(q,on);
qNexus_flow(q);
netStruct_return(on);
fclose(a);
}
return 0;
}
static int epoll_add(struct qengine_t *engine, int fd, int flags) {
int events, op;
epoll_t *epoll;
struct epoll_event event;
epoll = (epoll_t*)engine->data;
op = engine->events[fd].flags == QEVENT_NONE ? EPOLL_CTL_ADD : EPOLL_CTL_MOD;
flags |= engine->events[fd].flags;
events = 0;
if (flags & QEVENT_READ) {
events |= EPOLLIN;
}
if (flags & QEVENT_WRITE) {
events |= EPOLLOUT;
}
event.events = events;
event.data.fd = fd;
if (epoll_ctl(epoll->fd, op, fd, &event) == -1) {
qerror("epoll_ctl error: %s", strerror(errno));
return -1;
}
return 0;
}
static int
epoll_add(qengine_t *engine, int fd, int flags) {
int events, op;
qepoll_t *epoll;
struct epoll_event event;
epoll = (qepoll_t*)engine->data;
memset(&event, 0, sizeof(struct epoll_event));
if (engine->events[fd] == NULL) {
op = EPOLL_CTL_ADD;
} else {
op = EPOLL_CTL_MOD;
}
events = 0;
if (flags & QEVENT_READ) {
events |= EPOLLIN;
}
if (flags & QEVENT_WRITE) {
events |= EPOLLOUT;
}
//events |= EPOLLET;
event.events = events;
event.data.fd = fd;
if (epoll_ctl(epoll->fd, op, fd, &event) == -1) {
qerror("epoll_ctl error: %s", strerror(errno));
return QERROR;
}
return QOK;
}
long no_syscall(void *cpu_env, int num)
{
/* XXX: We should probably fordward it to the host kernel */
qerror("no unix syscall %d\n", num);
/* not reached */
return -1;
}
static inline void print_mach_msg_return(mach_msg_return_t ret)
{
int i, found = 0;
#define MACH_MSG_RET(msg) { msg, #msg }
struct { int code; char *name; } msg_name[] =
{
/* ref: http://darwinsource.opendarwin.org/10.4.2/xnu-792.2.4/osfmk/man/mach_msg.html */
/* send message */
MACH_MSG_RET(MACH_SEND_MSG_TOO_SMALL),
MACH_MSG_RET(MACH_SEND_NO_BUFFER),
MACH_MSG_RET(MACH_SEND_INVALID_DATA),
MACH_MSG_RET(MACH_SEND_INVALID_HEADER),
MACH_MSG_RET(MACH_SEND_INVALID_DEST),
MACH_MSG_RET(MACH_SEND_INVALID_NOTIFY),
MACH_MSG_RET(MACH_SEND_INVALID_REPLY),
MACH_MSG_RET(MACH_SEND_INVALID_TRAILER),
MACH_MSG_RET(MACH_SEND_INVALID_MEMORY),
MACH_MSG_RET(MACH_SEND_INVALID_RIGHT),
MACH_MSG_RET(MACH_SEND_INVALID_TYPE),
MACH_MSG_RET(MACH_SEND_INTERRUPTED),
MACH_MSG_RET(MACH_SEND_TIMED_OUT),
MACH_MSG_RET(MACH_RCV_BODY_ERROR),
MACH_MSG_RET(MACH_RCV_HEADER_ERROR),
MACH_MSG_RET(MACH_RCV_IN_SET),
MACH_MSG_RET(MACH_RCV_INTERRUPTED),
MACH_MSG_RET(MACH_RCV_INVALID_DATA),
MACH_MSG_RET(MACH_RCV_INVALID_NAME),
MACH_MSG_RET(MACH_RCV_INVALID_NOTIFY),
MACH_MSG_RET(MACH_RCV_INVALID_TRAILER),
MACH_MSG_RET(MACH_RCV_INVALID_TYPE),
MACH_MSG_RET(MACH_RCV_PORT_CHANGED),
MACH_MSG_RET(MACH_RCV_PORT_DIED),
MACH_MSG_RET(MACH_RCV_SCATTER_SMALL),
MACH_MSG_RET(MACH_RCV_TIMED_OUT),
MACH_MSG_RET(MACH_RCV_TOO_LARGE)
};
#undef MACH_MSG_RET
if( ret == MACH_MSG_SUCCESS)
DPRINTF("MACH_MSG_SUCCESS\n");
else
{
for( i = 0; i < sizeof(msg_name)/sizeof(msg_name[0]); i++) {
if(msg_name[i].code == ret) {
DPRINTF("%s\n", msg_name[i].name);
found = 1;
break;
}
}
if(!found)
qerror("unknow mach message ret code %d\n", ret);
}
}
/* ------------------------------------------------------------
thread type syscall handling
*/
long do_thread_syscall(void *cpu_env, int num, uint32_t arg1, uint32_t arg2, uint32_t arg3,
uint32_t arg4, uint32_t arg5, uint32_t arg6, uint32_t arg7,
uint32_t arg8)
{
extern uint32_t cthread_set_self(uint32_t);
extern uint32_t processor_facilities_used();
long ret = 0;
arg1 = tswap32(arg1);
arg2 = tswap32(arg2);
arg3 = tswap32(arg3);
arg4 = tswap32(arg4);
arg5 = tswap32(arg5);
arg6 = tswap32(arg6);
arg7 = tswap32(arg7);
arg8 = tswap32(arg8);
DPRINTF("thread syscall %d : " , num);
switch(num) {
#ifdef TARGET_I386
case 0x3:
#endif
case 0x7FF1: /* cthread_set_self */
DPRINTF("cthread_set_self(0x%x)\n", (unsigned int)arg1);
ret = cthread_set_self(arg1);
#ifdef TARGET_I386
/* we need to update the LDT with the address of the thread */
write_dt((void *)(((CPUX86State *) cpu_env)->ldt.base + (4 * sizeof(uint64_t))), arg1, 1,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
(3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
/* New i386 convention, %gs should be set to our this LDT entry */
cpu_x86_load_seg(cpu_env, R_GS, 0x27);
/* Old i386 convention, the kernel returns the selector for the cthread (pre-10.4.8?)*/
ret = 0x27;
#endif
break;
case 0x7FF2: /* Called the super-fast pthread_self handler by the apple guys */
DPRINTF("pthread_self()\n");
ret = (uint32_t)pthread_self();
break;
case 0x7FF3:
DPRINTF("processor_facilities_used()\n");
#ifdef __i386__
qerror("processor_facilities_used: not implemented!\n");
#else
ret = (uint32_t)processor_facilities_used();
#endif
break;
default:
gemu_log("qemu: Unsupported thread syscall: %d(0x%x)\n", num, num);
gdb_handlesig (cpu_env, SIGTRAP);
exit(0);
break;
}
return ret;
}
static inline void swap_mach_msg_body(struct complex_msg *complex_msg, int bswap)
{
mach_msg_port_descriptor_t *descr = (mach_msg_port_descriptor_t *)(complex_msg+1);
int i,j;
if(bswap == bswap_in)
tswap32s(&complex_msg->body.msgh_descriptor_count);
DPRINTF("body.msgh_descriptor_count %d\n", complex_msg->body.msgh_descriptor_count);
for(i = 0; i < complex_msg->body.msgh_descriptor_count; i++) {
switch(descr->type)
{
case MACH_MSG_PORT_DESCRIPTOR:
tswap32s(&descr->name);
descr++;
break;
case MACH_MSG_OOL_DESCRIPTOR:
{
mach_msg_ool_descriptor_t *ool = (void *)descr;
tswap32s((uint32_t *)&ool->address);
tswap32s(&ool->size);
descr = (mach_msg_port_descriptor_t *)(ool+1);
break;
}
case MACH_MSG_OOL_PORTS_DESCRIPTOR:
{
mach_msg_ool_ports_descriptor_t *ool_ports = (void *)descr;
mach_port_name_t * port_names;
if(bswap == bswap_in)
{
tswap32s((uint32_t *)&ool_ports->address);
tswap32s(&ool_ports->count);
}
port_names = ool_ports->address;
for(j = 0; j < ool_ports->count; j++)
tswap32s(&port_names[j]);
if(bswap == bswap_out)
{
tswap32s((uint32_t *)&ool_ports->address);
tswap32s(&ool_ports->count);
}
descr = (mach_msg_port_descriptor_t *)(ool_ports+1);
break;
}
default: qerror("unknow mach msg descriptor type %x\n", descr->type);
}
}
if(bswap == bswap_out)
tswap32s(&complex_msg->body.msgh_descriptor_count);
}
static int
qlerror(lua_State *state) {
const char* str;
str = lua_tostring(state, 1);
qerror("%s", str);
return 0;
}
long unimpl_unix_syscall(void *cpu_env, int num)
{
if( (num < 0) || (num > SYS_MAXSYSCALL-1) )
qerror("unix syscall %d is out of unix syscall bounds (0-%d) " , num, SYS_MAXSYSCALL-1);
gemu_log("qemu: Unsupported unix syscall %s %d\n", unix_syscall_table[num].name , num);
gdb_handlesig (cpu_env, SIGTRAP);
exit(-1);
}
long do_getdirentriesattr(uint32_t arg1, void * arg2, void * arg3, size_t arg4, void * arg5, void * arg6, void* arg7, uint32_t arg8)
{
DPRINTF("getdirentriesattr(0x%x, %p, %p, 0x%lx, %p, %p, %p, 0x%x)\n",
arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
#if defined(TARGET_I386) ^ defined(__i386__) || defined(TARGET_PPC) ^ defined(__ppc__)
qerror("SYS_getdirentriesattr unimplemented\n");
#endif
return get_errno(getdirentriesattr( arg1, (struct attrlist * )arg2, (void *)arg3, arg4,
(unsigned long *)arg5, (unsigned long *)arg6,
(unsigned long *)arg7, arg8));
}
int
qnet_tcp_listen(int port, const char *addr, int *error) {
int fd;
struct sockaddr_in sa;
if ((fd = create_listen_socket()) < 0) {
return QERROR;
}
if (set_nonblocking(fd) < 0) {
return QERROR;
}
memset(&sa,0,sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
*error = 0;
if (inet_aton(addr, &sa.sin_addr) == 0) {
qerror("invalid bind address");
*error = errno;
close(fd);
return QERROR;
}
if (bind(fd, (struct sockaddr*)&sa, sizeof(sa)) < 0) {
*error = errno;
qerror("bind error: %s", strerror(*error));
close(fd);
return QERROR;
}
if (listen(fd, 511) == -1) {
*error = errno;
qerror("listen error: %s", strerror(*error));
close(fd);
return QERROR;
}
return fd;
}
binding_data_nexus* deserialize_binding(serialize_control*sc)
{
binding_data_nexus *res=malloc(sizeof(binding_data_nexus));
if(!res)
qerror("Failed deserializing nexus data",0);
deserialize_int8(sc,&res->offset);
deserialize_int8(sc,&res->neo);
deserialize_int8(sc,&res->nert);
deserialize_int8(sc,res->name);
deserialize_int8(sc,res->name+1);
deserialize_int8(sc,res->name+2);
deserialize_int8(sc,res->name+3);
return res;
}
static int epoll_init(struct qengine_t *engine) {
epoll_t *epoll;
epoll = qalloc(engine->pool, sizeof(epoll_t));
if (epoll == NULL) {
return -1;
}
epoll->fd = epoll_create(1024);
if (epoll->fd == -1) {
qerror("epoll_create error: %s", strerror(errno));
return -1;
}
engine->data = epoll;
return 0;
}
qmsg_t*
qmsg_new(qid_t sender, qid_t recver, int size, int type) {
qmsg_t *msg;
msg = (qmsg_t*)qcalloc(size);
if (msg == NULL) {
qerror("alloc type %d msg error", type);
return NULL;
}
qlist_entry_init(&(msg->entry));
msg->sender = sender;
msg->recver = recver;
msg->type = type;
msg->size = size;
return msg;
}
long do_unix_syscall(void *cpu_env, int num)
{
long ret = 0;
DPRINTF("unix syscall %d: " , num);
if( (num < 0) || (num > SYS_MAXSYSCALL-1) )
qerror("unix syscall %d is out of unix syscall bounds (0-%d) " , num, SYS_MAXSYSCALL-1);
DPRINTF("%s [%s]", unix_syscall_table[num].name, unix_syscall_table[num].call_type & CALL_DIRECT ? "direct" : "indirect" );
ret = unix_syscall_table[num].function(cpu_env, num);
if(!(unix_syscall_table[num].call_type & CALL_NOERRNO))
ret = get_errno(ret);
DPRINTF("[returned 0x%x(%d)]\n", (int)ret, (int)ret);
return ret;
}
void netStruct_push_layer(netStruct*st,uint16_t offset)
{
if(offset!=0)
{
int16_t index;
for(index=0;index<MAX_ENCAPSULATION_LEVEL;index++)
{
if(!st->layers[index].status.bits.used)
{
st->layers[index].status.byte=0;
st->layers[index].status.bits.used=1;
st->layers[index].offset=offset;
return;
}
}
qerror("trying to push encapsulation on an already full NetworkStruct\n",1);
}
}
vec3 adv_att_control(quat setpoint, quat att, vec3 angle_rate)
{
static quat att_prev = UNIT_Q;
static vec3 error_sat_prev = VEC0;
static evec3 integral_out_prev = VEC0;
vec3 error = qerror(setpoint, att);
vec3 torques = VEC0;
evec3 ctrl_signal;
vec3 error_sat = vsat(error, integral_error_limit);
evec3 integral_out;
transmitData.x = PosGain.x;
transmitData.y = VelGain.x;
if (int_Disable) {
evec3 v0 = VEC0;
integral_out = v0;
} else {
integral_out = dvsum(dvsum(v_to_extended(error_sat_prev), v_to_extended(error_sat)), integral_out_prev);
}
integral_out_prev = integral_out;
error_sat_prev = error_sat;
integral_out.z = 0;
ctrl_signal = dvsum(
dvsub(
v_to_extended(vfmul_e2e(error, PosGain)),
//vimul2_e2e(angle_rate, VelGain)
vmul8_8(angle_rate, VelGain)
),
dvdiv(integral_out, int_gain_divide)
);
att_prev = att;
torques = evclip(ctrl_signal);
// FIXME: esto esta mal, es para poder probar sin que moleste el yaw
//torques.z = 0;
return torques;
}
long do_lseek(void *cpu_env, int num)
{
long ret;
int i = 0;
uint32_t arg1 = get_int_arg(&i, cpu_env);
uint64_t offset = get_int64_arg(&i, cpu_env);
uint32_t arg3 = get_int_arg(&i, cpu_env);
uint64_t r = lseek(arg1, offset, arg3);
#ifdef TARGET_I386
/* lowest word in eax, highest in edx */
ret = r & 0xffffffff; /* will be set to eax after do_unix_syscall exit */
((CPUX86State *)cpu_env)->regs[R_EDX] = (uint32_t)((r >> 32) & 0xffffffff) ;
#elif defined TARGET_PPC
ret = r & 0xffffffff; /* will be set to r3 after do_unix_syscall exit */
((CPUPPCState *)cpu_env)->gpr[4] = (uint32_t)((r >> 32) & 0xffffffff) ;
#else
qerror("64 bit ret value on your arch?");
#endif
return get_errno(ret);
}
