int
md_getframe(struct pstate *ps, int frame, struct md_frame *fram)
{
struct frame fr;
struct reg r;
int count;
if (process_getregs(ps, &r) != 0)
return (-1);
fr.fp = r.r_rbp;
fr.pc = r.r_rip;
for (count = 0; count < frame; count++) {
if (process_read(ps, fr.fp, &fr, sizeof(fr)) < 0)
return (-1);
if (fr.pc < 0x1000)
return (-1);
}
fram->pc = fr.pc;
fram->fp = fr.fp;
return (0);
}
SOCKET _gcc_socket_attach(process_t* p, mutex_t* lock) {
struct msghdr message;
struct iovec iov[1];
struct cmsghdr *control_message = NULL;
char ctrl_buf[CMSG_SPACE(sizeof(int))];
char data[1] = {' '};
int res;
memset(&message, 0, sizeof(struct msghdr));
memset(ctrl_buf, 0, CMSG_SPACE(sizeof(int)));
/* For the dummy data */
iov[0].iov_base = data;
iov[0].iov_len = sizeof(data);
message.msg_name = NULL;
message.msg_namelen = 0;
message.msg_control = ctrl_buf;
message.msg_controllen = CMSG_SPACE(sizeof(int));
message.msg_iov = iov;
message.msg_iovlen = 1;
if((res = recvmsg(p->pipe, &message, 0)) <= 0) {
socket_close(p->pipe);
return res;
}
printf("Reading mutex from client\n");
mutex_t mutexMem = (mutex_t) malloc(sizeof(_mutex_t));
const uint32_t nameSize = sizeof(mutexMem->name);
memset(mutexMem->name, 0, nameSize);
if(process_read(p, mutexMem->name, nameSize) != nameSize) {
printf("Could not read mutex data from process\n");
return INVALID_SOCKET;
}
if (mutex_attach(string(mutexMem->name), mutexMem) != ESERR_NO_ERROR) {
printf("Could not attach mutex from host process.\n");
return INVALID_SOCKET;
}
printf("Read mutex from client\n");
*lock = mutexMem;
// Iterate through header to find if there is a file descriptor
for(control_message = CMSG_FIRSTHDR(&message);
control_message != NULL;
control_message = CMSG_NXTHDR(&message,
control_message))
{
if( (control_message->cmsg_level == SOL_SOCKET) &&
(control_message->cmsg_type == SCM_RIGHTS) )
{
return *((int *) CMSG_DATA(control_message));
}
}
return INVALID_SOCKET;
}
static void on_events(handle_t h,int events){
kn_socket *s = (kn_socket*)h;
if(h->status == SOCKET_CLOSE)
return;
do{
h->inloop = 1;
if(h->status == SOCKET_LISTENING){
process_accept(s);
}else if(h->status == SOCKET_CONNECTING){
process_connect(s,events);
}else if(h->status == SOCKET_ESTABLISH){
if(events & EVENT_READ){
process_read(s);
if(h->status == SOCKET_CLOSE)
break;
}
if(events & EVENT_WRITE)
process_write(s);
}
h->inloop = 0;
}while(0);
if(h->status == SOCKET_CLOSE)
on_destroy(s);
}
int
md_getframe(struct pstate *ps, int frame, struct md_frame *fram)
{
struct frame64 fr;
struct reg r;
reg fp, pc;
reg *outs;
int i;
if (process_getregs(ps, &r))
return (-1);
if (frame == 0) {
pc = r.r_pc;
fp = r.r_out[6] + BIAS;
/*
* XXX - we need some kind of heuristics here to decide
* if the function has done a save or not and then pick
* the in registers. the problem is just that there are
* no in registers in PT_GETREGS.
*/
outs = (reg *)&r.r_out;
goto out;
}
fp = r.r_out[6] + BIAS;
pc = r.r_out[7];
for (i = 1; i < frame; i++) {
/* Too low or unaligned frame pointer? */
if (fp < 8192 || (fp & 7) != 0)
return (-1);
if (process_read(ps, fp, &fr, sizeof(fr)) < 0)
return (-1);
fp = (unsigned long)v9next_frame((&fr));
pc = fr.fr_pc;
/* Too low or unaligned pc ? */
if ((pc < 8192) || (pc & 3) != 0)
return (-1);
outs = (reg *)&fr.fr_arg;
}
out:
fram->pc = pc;
fram->fp = fp;
fram->nargs = 6; /* XXX - don't know the real number */
for (i = 0; i < 6; i++) {
fram->args[i] = fr.fr_arg[i];
}
return (0);
}
/*
* This is the entry point for reading data from a secure memory.
*/
int
omnius_read(blob_t *blob) {
int ret = EXIT_FAILURE;
/* find the proc based on pid */
secmem_process_t *proc = g_pid_lookup[blob->head.pid];
/* validate and process*/
if (proc && blob->head.addr >= 0 && blob->head.addr < proc->mem_size && blob->head.data_len > 0) {
/* assuming success, the process routine will stuff the data read into the data field of the blob
* */
ret = process_read(blob, proc);
}
return ret;
}
void service::process()
{
HTTP_CODE read_ret=process_read();
printf("process() read_ret=%d\n",read_ret);
if(read_ret==NO_REQUEST)
{
modfd(m_epollfd,m_sockfd,EPOLLIN);
return;
}
bool write_ret=process_write(read_ret);
if(!write_ret)
{
close_conn();
}
modfd(m_epollfd,m_sockfd,EPOLLOUT);
}
void
tcp_client::on_read_available(fd_t) {
__TACOPIE_LOG(info, "read available");
read_result result;
auto callback = process_read(result);
if (!result.success) {
__TACOPIE_LOG(warn, "read operation failure");
disconnect();
}
if (callback) { callback(result); }
if (!result.success) { call_disconnection_handler(); }
}
/* Called by each worker thread */
static void* worker_func(void* aio_context)
{
int num_events = -1, i = 0;
as_async_info_t *reference;
struct io_event events[MAXEVENTS];
while(g_running)
{
num_events = io_getevents(*(aio_context_t*)aio_context, 1, MAXEVENTS, (events + 0), NULL);
for(i = 0; i < num_events; i++)
{
reference = (as_async_info_t*)events[i].data;
process_read(reference);
}
}
return (0);
}
static void on_events(handle_t h,int events){
kn_chr_dev *r = (kn_chr_dev*)h;
r->processing = 1;
do{
if(events & EPOLLIN){
process_read(r);
if(r->comm_head.status == KN_CHRDEV_RELEASE)
break;
}
if(events & EPOLLOUT){
process_write(r);
}
}while(0);
r->processing = 0;
if(r->comm_head.status == KN_CHRDEV_RELEASE){
destroy_chrdev(r);
}
}
static int voice_test()
{
int rtn = 0;
char* name;
fd_set rfds, wfds;
Audio_t hPcm_Mic;
Audio_t hPcm_Spk;
snd_pcm_channel_params_t params;
bool bQuit = false;
/************************ CAPTURE **************************/
// configuring capture (mic)
name = "voice";
// get audioman handle
rtn = audio_manager_get_handle(AUDIO_TYPE_VIDEO_CHAT, getpid(), (bool)false, &hPcm_Mic.hAudioman);
if(rtn < 0) {
cli_print("audio_manager_get_handle (mic) failed %s", strerror(-rtn));
return -1;
}
cli_print("Opening %s - for capture", name);
rtn = snd_pcm_open_name(&hPcm_Mic.pDs, name, SND_PCM_OPEN_CAPTURE);
if (rtn < 0) {
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
cli_print("snd_pcm_open_name (mic) failed %s", snd_strerror(rtn));
return -1; // snd_pcm calls return negative values; make positive
}
rtn = snd_pcm_set_audioman_handle(hPcm_Mic.pDs, hPcm_Mic.hAudioman);
if (rtn < 0) {
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
cli_print("snd_pcm_set_audioman_handle (mic) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
return -1;
}
// disable mmap
(void)snd_pcm_plugin_set_disable(hPcm_Mic.pDs, (unsigned int)PLUGIN_DISABLE_MMAP);
// set parameters
memset(¶ms, 0, sizeof(params));
params.mode = SND_PCM_MODE_BLOCK;
params.channel = SND_PCM_CHANNEL_CAPTURE;
params.start_mode = SND_PCM_START_GO;
params.stop_mode = SND_PCM_STOP_ROLLOVER;
params.buf.block.frag_size = fragsize;
params.buf.block.frags_max = 1;
params.buf.block.frags_min = 1;
params.format.rate = 8000; //samplerate;
params.format.interleave = 1;
params.format.voices = channels;
params.format.format = SND_PCM_SFMT_S16_LE;
rtn = snd_pcm_plugin_params(hPcm_Mic.pDs, ¶ms);
if (rtn < 0) {
cli_print("snd_pcm_plugin_params (mic) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
return -1;
}
// get file descriptor for use with the select() call
hPcm_Mic.hFD = snd_pcm_file_descriptor(hPcm_Mic.pDs, SND_PCM_CHANNEL_CAPTURE);
if (hPcm_Mic.hFD < 0) {
cli_print("snd_pcm_file_descriptor (mic) failed %s", snd_strerror(hPcm_Mic.hFD));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
return -1;
}
// Signal the driver to ready the capture channel
rtn = snd_pcm_plugin_prepare(hPcm_Mic.pDs, SND_PCM_CHANNEL_CAPTURE);
if (rtn < 0) {
cli_print("snd_pcm_plugin_prepare (mic) failed %s", snd_strerror(errno));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
return -1;
}
fragsize = params.buf.block.frag_size;
/************************ PLAYBACK **************************/
name = "voice";
// get and set audioman handle
rtn = audio_manager_get_handle(AUDIO_TYPE_VIDEO_CHAT, getpid(), (bool)false, &hPcm_Spk.hAudioman);
if (rtn < 0) {
cli_print("audioman audio_manager_get_handle (spk) failed %s", strerror(-rtn) );
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
return -1;
}
#ifdef HANDSET
// set audio manager handle type
rtn = audio_manager_set_handle_type(hPcm_Spk.hAudioman, AUDIO_TYPE_VIDEO_CHAT, device_type, device_type);
if (rtn < 0) {
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
cli_print("audio_manager_set_handle_type (spk) failed %s", strerror(-rtn));
return -1;
}
#endif
// Create a handle and open a connection to an audio interface specified by name
cli_print("Opening %s - for playback", name);
rtn = snd_pcm_open_name(&hPcm_Spk.pDs, name, SND_PCM_OPEN_PLAYBACK);
if (rtn < 0) {
cli_print("snd_pcm_open_name (spk) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
rtn = snd_pcm_set_audioman_handle(hPcm_Spk.pDs, hPcm_Spk.hAudioman);
if (rtn < 0) {
cli_print("snd_pcm_set_audioman_handle (spk) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
// disable mmap
(void)snd_pcm_plugin_set_disable(hPcm_Spk.pDs, (unsigned int)PLUGIN_DISABLE_MMAP);
// set parameters
memset(¶ms, 0, sizeof(params));
params.mode = SND_PCM_MODE_BLOCK;
params.channel = SND_PCM_CHANNEL_PLAYBACK;
params.start_mode = SND_PCM_START_GO;
params.stop_mode = SND_PCM_STOP_ROLLOVER;
params.buf.block.frag_size = fragsize;
params.buf.block.frags_max = 1;
params.buf.block.frags_min = 1;
params.format.rate = samplerate;
params.format.interleave = 1;
params.format.voices = channels;
params.format.format = SND_PCM_SFMT_S16_LE;
// Set the configurable parameters for a PCM channel
rtn = snd_pcm_plugin_params(hPcm_Spk.pDs, ¶ms);
if (rtn < 0) {
cli_print("snd_pcm_plugin_params (spk) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
// get file descriptor for use with the select() call
hPcm_Spk.hFD = snd_pcm_file_descriptor(hPcm_Spk.pDs, SND_PCM_CHANNEL_PLAYBACK);
if (hPcm_Spk.hFD < 0) {
cli_print("snd_pcm_file_descriptor (spk) failed %s", snd_strerror(hPcm_Spk.hFD));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
// Signal the driver to ready the playback channel
rtn = snd_pcm_plugin_prepare(hPcm_Spk.pDs, SND_PCM_CHANNEL_PLAYBACK);
if (rtn < 0) {
cli_print("snd_pcm_plugin_prepare (spk) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
fragsize = params.buf.block.frag_size;
rtn = snd_pcm_capture_go(hPcm_Mic.pDs);
if( rtn < 0) {
cli_print("snd_pcm_capture_go (mic) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
rtn = snd_pcm_playback_go(hPcm_Spk.pDs);
if (rtn < 0) {
cli_print("snd_pcm_playback_go (spk) failed %s", snd_strerror(rtn));
(void)snd_pcm_close(hPcm_Mic.pDs);
(void)snd_pcm_close(hPcm_Spk.pDs);
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
return -1;
}
/******************* PLAYBACK/RECORD LOOP **************************/
while(!bQuit)
{
int width;
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 350000; // 350 ms
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_SET(hPcm_Mic.hFD, &rfds);
FD_SET(hPcm_Spk.hFD, &wfds);
width = ((hPcm_Spk.hFD > hPcm_Mic.hFD) ? hPcm_Spk.hFD : hPcm_Mic.hFD) + 1;
rtn = select(width, &rfds, &wfds, NULL, &timeout);
if (rtn > 0) {
if (FD_ISSET(hPcm_Spk.hFD, &wfds)) {
bQuit = process_write(hPcm_Spk.pDs);
}
if (FD_ISSET(hPcm_Mic.hFD, &rfds)) {
bQuit = process_read(hPcm_Mic.pDs);
}
}
else if (rtn == 0){
cli_print("select: timed out");
bQuit = true;
}
else { // (rtn < 0)
cli_print("select: %s", strerror(errno));
bQuit = true;
}
}
// Ensure audio processing is stopped
if ((rtn = snd_pcm_plugin_playback_drain(hPcm_Spk.pDs)) < 0) {
cli_print("snd_pcm_plugin_playback_drain (spk) failed %s", snd_strerror(rtn));
}
if ((rtn = snd_pcm_plugin_flush(hPcm_Mic.pDs, SND_PCM_CHANNEL_CAPTURE)) < 0) {
cli_print("snd_pcm_plugin_flush (mic) failed %s", snd_strerror(rtn));
}
if ((rtn = snd_pcm_close(hPcm_Spk.pDs)) < 0) {
cli_print("snd_pcm_close (spk) failed %s", snd_strerror(rtn));
}
if ((rtn = snd_pcm_close(hPcm_Mic.pDs)) < 0) {
cli_print("snd_pcm_close (mic) failed %s", snd_strerror(rtn));
}
if (hPcm_Spk.hAudioman) {
(void)audio_manager_free_handle(hPcm_Spk.hAudioman);
}
if (hPcm_Mic.hAudioman) {
(void)audio_manager_free_handle(hPcm_Mic.hAudioman);
}
return 0;
}
static void
process(void)
{
u_int msg_len;
u_int buf_len;
u_int consumed;
u_int type;
u_char *cp;
buf_len = buffer_len(&iqueue);
if (buf_len < 5)
return; /* Incomplete message. */
cp = buffer_ptr(&iqueue);
msg_len = GET_32BIT(cp);
if (msg_len > 256 * 1024) {
error("bad message ");
exit(11);
}
if (buf_len < msg_len + 4)
return;
buffer_consume(&iqueue, 4);
buf_len -= 4;
type = buffer_get_char(&iqueue);
switch (type) {
case SSH2_FXP_INIT:
process_init();
break;
case SSH2_FXP_OPEN:
process_open();
break;
case SSH2_FXP_CLOSE:
process_close();
break;
case SSH2_FXP_READ:
process_read();
break;
case SSH2_FXP_WRITE:
process_write();
break;
case SSH2_FXP_LSTAT:
process_lstat();
break;
case SSH2_FXP_FSTAT:
process_fstat();
break;
case SSH2_FXP_SETSTAT:
process_setstat();
break;
case SSH2_FXP_FSETSTAT:
process_fsetstat();
break;
case SSH2_FXP_OPENDIR:
process_opendir();
break;
case SSH2_FXP_READDIR:
process_readdir();
break;
case SSH2_FXP_REMOVE:
process_remove();
break;
case SSH2_FXP_MKDIR:
process_mkdir();
break;
case SSH2_FXP_RMDIR:
process_rmdir();
break;
case SSH2_FXP_REALPATH:
process_realpath();
break;
case SSH2_FXP_STAT:
process_stat();
break;
case SSH2_FXP_RENAME:
process_rename();
break;
case SSH2_FXP_READLINK:
process_readlink();
break;
case SSH2_FXP_SYMLINK:
process_symlink();
break;
case SSH2_FXP_EXTENDED:
process_extended();
break;
default:
error("Unknown message %d", type);
break;
}
/* discard the remaining bytes from the current packet */
if (buf_len < buffer_len(&iqueue))
fatal("iqueue grows");
consumed = buf_len - buffer_len(&iqueue);
if (msg_len < consumed)
fatal("msg_len %d < consumed %d", msg_len, consumed);
if (msg_len > consumed)
buffer_consume(&iqueue, msg_len - consumed);
}
static void
process(void)
{
u_int msg_len;
u_int buf_len;
u_int consumed;
u_int type;
u_char *cp;
buf_len = buffer_len(&iqueue);
if (buf_len < 5)
return; /* Incomplete message. */
cp = buffer_ptr(&iqueue);
msg_len = get_u32(cp);
if (msg_len > SFTP_MAX_MSG_LENGTH) {
error("bad message from %s local user %s",
client_addr, pw->pw_name);
sftp_server_cleanup_exit(11);
}
if (buf_len < msg_len + 4)
return;
buffer_consume(&iqueue, 4);
buf_len -= 4;
type = buffer_get_char(&iqueue);
switch (type) {
case SSH2_FXP_INIT:
process_init();
break;
case SSH2_FXP_OPEN:
process_open();
break;
case SSH2_FXP_CLOSE:
process_close();
break;
case SSH2_FXP_READ:
process_read();
break;
case SSH2_FXP_WRITE:
process_write();
break;
case SSH2_FXP_LSTAT:
process_lstat();
break;
case SSH2_FXP_FSTAT:
process_fstat();
break;
case SSH2_FXP_SETSTAT:
process_setstat();
break;
case SSH2_FXP_FSETSTAT:
process_fsetstat();
break;
case SSH2_FXP_OPENDIR:
process_opendir();
break;
case SSH2_FXP_READDIR:
process_readdir();
break;
case SSH2_FXP_REMOVE:
process_remove();
break;
case SSH2_FXP_MKDIR:
process_mkdir();
break;
case SSH2_FXP_RMDIR:
process_rmdir();
break;
case SSH2_FXP_REALPATH:
process_realpath();
break;
case SSH2_FXP_STAT:
process_stat();
break;
case SSH2_FXP_RENAME:
process_rename();
break;
case SSH2_FXP_READLINK:
process_readlink();
break;
case SSH2_FXP_SYMLINK:
process_symlink();
break;
case SSH2_FXP_EXTENDED:
process_extended();
break;
default:
error("Unknown message %d", type);
break;
}
/* discard the remaining bytes from the current packet */
if (buf_len < buffer_len(&iqueue)) {
error("iqueue grew unexpectedly");
sftp_server_cleanup_exit(255);
}
consumed = buf_len - buffer_len(&iqueue);
if (msg_len < consumed) {
error("msg_len %d < consumed %d", msg_len, consumed);
sftp_server_cleanup_exit(255);
}
if (msg_len > consumed)
buffer_consume(&iqueue, msg_len - consumed);
}
void SFTP::process(void)
{
const u_int msg_len = buffer_get_int (&iqueue);
const u_int type = buffer_get_char(&iqueue);
switch (type) {
case SSH2_FXP_INIT:
process_init();
break;
case SSH2_FXP_OPEN:
process_open();
break;
case SSH2_FXP_CLOSE:
process_close();
break;
case SSH2_FXP_READ:
process_read();
break;
case SSH2_FXP_WRITE:
process_write();
break;
case SSH2_FXP_LSTAT:
process_lstat();
break;
case SSH2_FXP_FSTAT:
process_fstat();
break;
case SSH2_FXP_SETSTAT:
process_setstat();
break;
case SSH2_FXP_FSETSTAT:
process_fsetstat();
break;
case SSH2_FXP_OPENDIR:
process_opendir();
break;
case SSH2_FXP_READDIR:
process_readdir();
break;
case SSH2_FXP_REMOVE:
process_remove();
break;
case SSH2_FXP_MKDIR:
process_mkdir();
break;
case SSH2_FXP_RMDIR:
process_rmdir();
break;
case SSH2_FXP_REALPATH:
process_realpath();
break;
case SSH2_FXP_STAT:
process_stat();
break;
case SSH2_FXP_RENAME:
process_rename();
break;
case SSH2_FXP_READLINK:
process_readlink();
break;
case SSH2_FXP_SYMLINK:
process_symlink();
break;
case SSH2_FXP_EXTENDED:
process_extended();
break;
default:
error("Unknown message %d", type);
break;
}
/* discard the remaining bytes from the current packet */
if (msg_len < buffer_len(&iqueue)) {
error("iqueue grew unexpectedly");
sftp_server_cleanup_exit(255);
}
u_int consumed = msg_len - buffer_len(&iqueue);
if (msg_len < consumed) {
error("msg_len %d < consumed %d", msg_len, consumed);
sftp_server_cleanup_exit(255);
}
if (msg_len > consumed)
buffer_consume(&iqueue, msg_len - consumed);
}
// generates code to implement node's action
static void implement_node(ast_node node){
if (node != NULL){
if (node->node_type == ROOT){
process_root(node);
}
// generate code for assignment operator
else if (node->node_type == OP_ASSIGN){
process_assign(node);
}
// generate code for negate operator
else if (node->node_type == OP_NEG) {
process_negate(node);
}
// generate code for +, -, *, /, %, =, !=, <, <=, >, >=
else if (node->node_type > 0 && node->node_type <= 16 && node->node_type != 14 && node->node_type != 15){
process_math(node);
}
else if (node->node_type == OP_INC){
process_inc(node, "1");
}
else if (node->node_type == OP_DEC){
process_inc(node, "-1");
}
else if (node->node_type == IF_STMT){
process_if(node);
}
else if (node->node_type == IF_ELSE_STMT){
process_ifelse(node);
}
else if (node->node_type == CMPD){
process_cmpd(node);
}
else if (node->node_type == WHILE_STMT){
process_while(node);
}
else if (node->node_type == DO_WHILE_STMT){
process_dowhile(node);
}
else if (node->node_type == OP_AND){
process_and(node);
}
else if (node->node_type == OP_OR){
process_or(node);
}
else if (node->node_type == FOR_STRT || node->node_type == FOR_COND || node->node_type == FOR_UPDT){
process_for_header(node);
}
else if (node->node_type == FOR_STMT){
process_for(node);
}
else if (node->node_type == READ_STMT){
process_read(node);
}
else if (node->node_type == PRINT_STMT){
process_print(node);
}
else if (node->node_type == RETURN_STMT){
process_return(node);
}
else if (node->node_type == FUNCDEC){
process_function(node);
}
else if (node->node_type == PARAMS){
process_params(node);
}
else if (node->node_type == INT_TYPE || node->node_type == DOUBLE_TYPE){
process_vardec(node);
}
else if (node->node_type == CALL){
process_call(node);
}
else if (node->node_type == IDENT){
process_id(node);
}
else if (node->node_type == ARRAY){
process_array(node);
}
}
}
void *router_thread(struct wiimote *wiimote)
{
unsigned char buf[READ_BUF_LEN];
ssize_t len;
struct mesg_array ma;
char err, print_clock_err = 1;
while (1) {
/* Read packet */
len = read(wiimote->int_socket, buf, READ_BUF_LEN);
ma.count = 0;
if (clock_gettime(CLOCK_REALTIME, &ma.timestamp)) {
if (print_clock_err) {
cwiid_err(wiimote, "clock_gettime error");
print_clock_err = 0;
}
}
err = 0;
if ((len == -1) || (len == 0)) {
process_error(wiimote, len, &ma);
write_mesg_array(wiimote, &ma);
/* Quit! */
break;
}
else {
/* Verify first byte (DATA/INPUT) */
if (buf[0] != (BT_TRANS_DATA | BT_PARAM_INPUT)) {
cwiid_err(wiimote, "Invalid packet type");
}
/* Main switch */
/* printf("%.2X %.2X %.2X %.2X %.2X %.2X %.2X %.2X\n", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
printf("%.2X %.2X %.2X %.2X %.2X %.2X %.2X %.2X\n", buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
printf("%.2X %.2X %.2X %.2X %.2X %.2X %.2X %.2X\n", buf[16], buf[17], buf[18], buf[19], buf[20], buf[21], buf[22], buf[23]);
printf("\n"); */
switch (buf[1]) {
case RPT_STATUS:
err = process_status(wiimote, &buf[2], &ma);
break;
case RPT_BTN:
err = process_btn(wiimote, &buf[2], &ma);
break;
case RPT_BTN_ACC:
err = process_btn(wiimote, &buf[2], &ma) ||
process_acc(wiimote, &buf[4], &ma);
break;
case RPT_BTN_EXT8:
err = process_btn(wiimote, &buf[2], &ma) ||
process_ext(wiimote, &buf[4], 8, &ma);
break;
case RPT_BTN_ACC_IR12:
err = process_btn(wiimote, &buf[2], &ma) ||
process_acc(wiimote, &buf[4], &ma) ||
process_ir12(wiimote, &buf[7], &ma);
break;
case RPT_BTN_EXT19:
err = process_btn(wiimote, &buf[2], &ma) ||
process_ext(wiimote, &buf[4], 19, &ma);
break;
case RPT_BTN_ACC_EXT16:
err = process_btn(wiimote, &buf[2], &ma) ||
process_acc(wiimote, &buf[4], &ma) ||
process_ext(wiimote, &buf[7], 16, &ma);
break;
case RPT_BTN_IR10_EXT9:
err = process_btn(wiimote, &buf[2], &ma) ||
process_ir10(wiimote, &buf[4], &ma) ||
process_ext(wiimote, &buf[14], 9, &ma);
break;
case RPT_BTN_ACC_IR10_EXT6:
err = process_btn(wiimote, &buf[2], &ma) ||
process_acc(wiimote, &buf[4], &ma) ||
process_ir10(wiimote, &buf[7], &ma) ||
process_ext(wiimote, &buf[17], 6, &ma);
break;
case RPT_EXT21:
err = process_ext(wiimote, &buf[2], 21, &ma);
break;
case RPT_BTN_ACC_IR36_1:
case RPT_BTN_ACC_IR36_2:
cwiid_err(wiimote, "Unsupported report type received "
"(interleaved data)");
err = 1;
break;
case RPT_READ_DATA:
err = process_read(wiimote, &buf[4]) ||
process_btn(wiimote, &buf[2], &ma);
break;
case RPT_WRITE_ACK:
err = process_write(wiimote, &buf[2]);
break;
default:
cwiid_err(wiimote, "Unknown message type");
err = 1;
break;
}
if (!err && (ma.count > 0)) {
if (update_state(wiimote, &ma)) {
cwiid_err(wiimote, "State update error");
}
if (wiimote->flags & CWIID_FLAG_MESG_IFC) {
/* prints its own errors */
write_mesg_array(wiimote, &ma);
}
}
}
}
return NULL;
}
int main(int argc, char *argv[]) {
u32 i,
argi,
found,
offset,
listsign = 0,
dumpsign = 0;
u8 *pid = NULL,
*dumpfile = NULL,
*sign_file = NULL;
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
fputs("\n"
"Signsrch "VER"\n"
"by Luigi Auriemma\n"
"e-mail: [email protected]\n"
"web: aluigi.org\n"
" optimized search function from Andrew http://www.team5150.com/~andrew/\n"
"\n", stderr);
if(argc < 2) {
help(argv[0]);
}
for(i = 1; i < argc; i++) {
if(!stricmp(argv[i], "--help")) help(argv[0]);
if(((argv[i][0] != '-') && (argv[i][0] != '/')) || (strlen(argv[i]) != 2)) break;
switch(argv[i][1]) {
case '-':
case 'h':
case '?': {
help(argv[0]);
} break;
case 'l': {
listsign = 1;
} break;
case 'L': {
if(!argv[++i]) {
printf("\nError: signature number needed\n");
exit(1);
}
dumpsign = atoi(argv[i]);
} break;
case 's': {
if(!argv[++i]) {
printf("\nError: signature filename needed\n");
exit(1);
}
sign_file = argv[i];
} break;
case 'p': {
pid = "";
} break;
case 'P': {
if(!argv[++i]) {
printf("\nError: process name or pid needed\n");
exit(1);
}
pid = argv[i];
} break;
case 'd': {
if(!argv[++i]) {
printf("\nError: dump file name needed\n");
exit(1);
}
dumpfile = argv[i];
} break;
case 'e': {
exe_scan = 1;
} break;
case 'E': {
exe_scan = -1;
} break;
case 'b': {
alt_endian = 0;
} break;
default: {
printf("\nError: wrong argument (%s)\n", argv[i]);
exit(1);
} break;
}
}
argi = i;
sign = NULL;
signs = 0;
sign_alloclen = 0;
if(pid && !pid[0]) {
process_list(NULL, NULL, NULL);
goto quit;
}
redo:
if(!listsign && !dumpsign) {
if(pid) {
filemem = process_read(pid, &filememsz);
if(!exe_scan) exe_scan = 1;
} else {
if(i == argc) {
printf("\nError: you must specify the file to scan\n");
exit(1);
}
filemem = fd_read(argv[argi], &filememsz);
}
printf("- %u bytes allocated\n", filememsz);
}
if(dumpfile) {
fd_write(dumpfile, filemem, filememsz);
goto quit;
}
if(!sign) {
printf("- load signatures\n");
if(!sign_file) {
read_cfg(get_main_path(SIGNFILE, argv[0]));
} else {
read_cfg(sign_file);
}
printf(
"- %u bytes allocated for the signatures\n"
"- %u signatures in the database\n",
sign_alloclen,
signs);
if(!dumpsign) signcrc();
}
if(dumpsign > 0) {
dumpsign--;
if(dumpsign >= signs) {
printf("\nError: wrong signature number\n");
exit(1);
}
printf(" %s\n", sign[dumpsign]->title);
show_dump(sign[dumpsign]->data, sign[dumpsign]->size, stdout);
goto quit;
}
if(listsign) {
printf("\n"
" num description [bits.endian.size]\n"
"-------------------------------------\n");
for(i = 0; i < signs; i++) {
printf(" %-4u %s\n", i + 1, sign[i]->title);
}
printf("\n");
goto quit;
}
if(filememsz > (10 * 1024 * 1024)) { // more than 10 megabytes
printf(
"- WARNING:\n"
" the file loaded in memory is very big so the scanning could take many time\n");
}
if(exe_scan > 0) {
if(parse_exe() < 0) {
printf(
"- input is not an executable or is not supported by this tool\n"
" the data will be handled in raw mode\n");
exe_scan = 0;
}
}
printf(
"- start signatures scanning:\n"
"\n"
" offset num description [bits.endian.size]\n"
" --------------------------------------------\n");
for(found = i = 0; i < signs; i++) {
offset = search_hashed(filemem, filememsz, sign[i]->data, sign[i]->size, sign[i]->and);
if(offset != -1) {
if(exe_scan > 0) offset = file2rva(offset);
if(exe_scan < 0) offset += fixed_rva;
printf(" %08x %-4u %s\n", offset, i + 1, sign[i]->title);
found++;
}
}
printf("\n- %u signatures found in the file\n", found);
if(filemem) free(filemem);
if(section) free(section);
filemem = NULL;
section = NULL;
if(++argi < argc) {
fputc('\n', stdout);
goto redo;
}
quit:
if(sign) free_sign();
return(0);
}
int main(int argc, char * argv[]) {
if(argc < 3 || argc > 4) {
print_usage();
}
int i = 0;
if(argc == 4) {
if(strcmp(argv[1], "-d")) {
print_usage();
}
debug = 1;
i = 1;
}
int portno = atoi(argv[++i]);
set_dropper(atoi(argv[++i]));
if((socket_descriptor = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
fprintf(stderr, "Could not create socket.\n");
exit(2);
}
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(portno);
init();
if(bind(socket_descriptor, (struct sockaddr *) &server, sizeof(server)) < 0) {
fprintf(stderr, "Could not bind socket to port %d.\n", portno);
exit(3);
}
if(debug)
printf("Server started on port %d.\n", portno);
serving = 0;
max_in_size = 1024;
in_buffer = (uchar *)malloc(max_in_size*sizeof(uchar));
src = &client;
while(1) {
if(!serving) {
accept_connection();
} else if(!prepare_packet()) {
if(write_read_data()) {
printf("Error while receiving data. Terminating Connection");
finished = 0;
serving = 0;
free(out_buffer);
continue;
}
process_read();
}
}
return 0;
}
/**
* Reads the specified number of bytes from memory uint32_to the buffer.
* If all of the bytes could not be read, a ReadException is thrown.
*
* @param address The starting address to read from.
* @param buffer The destination buffer to save uint32_to.
* @param size The number of bytes to read.
*/
void Read(uint32_t address, void* buffer, size_t size) const { StackTrace trace(__METHOD__, __FILE__, __LINE__);
if (process_read(_handle, address, buffer, size) == false) {
throw ReadException();
}
}
