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