void end_aktion (void)
{
if (akt_handle > 0)
{
int msg[8], d, event = 0;
wind_close(akt_handle);
wind_delete(akt_handle);
akt_handle = -1;
/*
* Alle auflaufenden Redraw-Messages abarbeiten, damit
* alle Fenster sauber sind, wenn der Dialog beendet ist.
*/
while (event != MU_TIMER)
{
event = evnt_multi(MU_MESAG|MU_TIMER, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
msg, 1, &d, &d, &d, &d, &d, &d);
if ((event & MU_MESAG) && (msg[0] == WM_REDRAW))
handle_msg(msg);
}
/* Men� wieder an */
enable_menu();
}
}
void handle_recvmsg (struct process *process, ssize_t ret, int sockfd, struct msghdr *msg, int flags)
{
if (ret < 0)
return;
(void) msg;
(void) flags;
struct descriptor *descriptor;
if (!(descriptor = get_netlink_descriptor (process, sockfd)))
return;
unsigned char *data = NULL;
if (!(data = malloc (ret)))
{
perror ("malloc");
goto end;
}
if (handle_msg (data, ret, process, msg) == -1)
{
fprintf (stderr, "handle_msg FAILED\n");
goto end;
}
descriptor_handle_recv (descriptor, data, ret);
/* was already handled/freed */
data = NULL;
end:
free (data);
}
void handle_sendmsg (struct process *process, ssize_t ret, int sockfd, const struct msghdr *msg, int flags)
{
if (ret < 0)
return;
(void) msg;
(void) flags;
struct descriptor *descriptor;
if (!(descriptor = get_netlink_descriptor (process, sockfd)))
return;
unsigned char *data = NULL;
// TODO: we must detect total length of original message (!)
if (!(data = malloc (ret)))
{
perror ("malloc");
goto end;
}
if (handle_msg (data, ret, process, msg) == -1)
{
fprintf (stderr, "handle_msg FAILED\n");
goto end;
}
descriptor_handle_send (descriptor, data, ret);
/* was already handled/freed */
data = NULL;
end:
free (data);
}
static int handle_enter(int x, int y)
{
char *line = NULL;
/* Handle when a user presses enter.
- Save the contents of the line.
- Set the prompt to nothing.
- Blank the line.
- pass the message to the message handler
- rl_copy_text returns malloc'd mem, so free it
- restore the prompt
- tell readline we're done mucking
*/
line = rl_copy_text(0, rl_end);
rl_set_prompt("");
rl_replace_line("", 1);
rl_redisplay();
handle_msg(line);
free(line);
rl_set_prompt(PROMPT);
rl_redisplay();
rl_done = 1;
return 0;
}
int mysql_dissector(struct tcp_stream* tcp, void** no_need_param){
struct half_stream* stream;
int msg_type;
int ret = 0;
if(tcp->client.count_new){
stream = &tcp->client;
/* the msg is sent by server so the message is server type*/
msg_type = MYSQL_SERVER_MSG;
}else{
stream = &tcp->server;
msg_type = MYSQL_CLIENT_MSG;
}
mysql_session* sess = get_mysql_session(&tcp->addr);
/* FIXME: it shouldn't be null, but it can be null in some case.*/
//DEBUG_ASSERT(sess != NULL);
if(sess != NULL){
ret = handle_resume_state(sess, msg_type);
if(ret == SESSION_STATE_PROCESS_CONTINUE){
ret = handle_msg(stream, msg_type, sess);
if(ret == STREAM_DISCARD){
/* leave the data we have received but not unhandled to next call */
nids_discard(tcp, sess->handled_len);
sess->handled_len = 0;
}
}else{
log_runtime_error("handle canceled due to resume state");
}
}else{
log_runtime_error("Cannot get a session");
}
return ret;
}
void read_serial(int fd) {
int bytes, total, proc;
// Data on the serial port
ioctl(fd, FIONREAD, &bytes);
if (bytes < 0) return;
bytes = read(fd, &serial_buffer[in_buffer], BUFFER_SIZE - in_buffer);
if (bytes == -1) {
ERROR(1, "Error reading from serial port: %d (%s)\n", errno, strerror(errno));
} else {
fwrite(&serial_buffer[in_buffer], 1, bytes, stdout);
fflush(stdout);
in_buffer += bytes;
}
if (in_buffer > 0) {
for (total = 0, proc = 1; proc && in_buffer > 0 && total < in_buffer; total += proc) {
proc = handle_msg(&serial_buffer[total], in_buffer - total);
}
if (total && in_buffer > 0) {
if (total >= in_buffer) {
in_buffer = 0;
} else {
memmove(serial_buffer, &(serial_buffer[total]), in_buffer - total);
in_buffer -= total;
}
}
}
}
bool
No1ServerSession::recv_msg()
{
while (true)
{
if (static_cast<int>(kBufferLen) - m_recv_len < static_cast<int>(kPerReadSize))
{
char* buffer = new char [2 * m_recv_len];
memcpy(buffer, m_recv_buffer, m_recv_len);
delete[] m_recv_buffer;
m_recv_buffer = buffer;
}
int size = ::read(m_sock_fd, m_recv_buffer + m_recv_len, static_cast<int>(kPerReadSize));
if (size == -1)
{
if (errno == EAGAIN)
{
handle_msg();
return true;
} else {
disconnect();
return false;
}
}else if (size == 0){
disconnect();
} else {
m_recv_len += size;
continue;
}
}
return false;
}
static int
handle_buffer(struct rev_server *revsrv, struct rev_client *cl)
{
struct FIFOBUF *inbuf = INBUF(cl);
if (fifo_len(inbuf) < 3)
return 0; /* not enough data */
int msg_size = *((uint16_t*)inbuf->data);
int msg_id = *((uint8_t*)(inbuf->data+2));
ASSERT(msg_size <= MAX_MSG_SIZE, "invalid msg size")
if (fifo_len(inbuf) < 3 + msg_size)
return 0; /* not enough data */
/* skip size & id */
fifo_read(inbuf, NULL, 3);
char buf[MAX_MSG_SIZE];
struct netmsg msg;
msg.id = msg_id;
msg.size = msg_size;
msg.data = buf;
//printf("got msg id %d size %d\n", msg_id, msg_size);
/* read and handle message */
fifo_read(inbuf, buf, msg_size);
ASSERT(handle_msg(revsrv, cl, &msg) == 0, "invalid msg");
if (fifo_len(inbuf) > 0)
return 1; /* there is data left */
return 0;
}
MuError
mu_cmd_view (MuConfig *opts, GError **err)
{
int i;
gboolean rv;
g_return_val_if_fail (opts, MU_ERROR_INTERNAL);
g_return_val_if_fail (opts->cmd == MU_CONFIG_CMD_VIEW,
MU_ERROR_INTERNAL);
rv = view_params_valid(opts, err);
if (!rv)
goto leave;
for (i = 1; opts->params[i]; ++i) {
rv = handle_msg (opts->params[i], opts, err);
if (!rv)
break;
/* add a separator between two messages? */
if (opts->terminator)
g_print ("%c", VIEW_TERMINATOR);
}
leave:
if (!rv)
return err && *err ? (*err)->code : MU_ERROR;
return MU_OK;
}
static int read_msg(bano_list_item_t* li, void* p)
{
bano_socket_t* const socket = li->data;
const int fd = bano_socket_get_fd(socket);
struct prw_msg_data* const prwmd = p;
int err;
#ifdef BANO_CONFIG_HTTPD
bano_httpd_msg_t httpd_msg;
#endif /* BANO_CONFIG_HTTPD */
bano_msg_t bano_msg;
void* msg;
msg_handler_t handle_msg;
if (FD_ISSET(fd, prwmd->fds) == 0) return 0;
/* TODO: use while loop instead of if. doing so */
/* TODO: requires to retrieve the exact errno */
/* TODO: code from sub layer and differentiate */
/* TODO: between end of file, wouldblock ... */
/* TODO: for now, assume closed on error */
if (socket->type == BANO_SOCKET_TYPE_SNRF)
{
msg = &bano_msg;
handle_msg = handle_bano_msg;
}
#ifdef BANO_CONFIG_HTTPD
else if (socket->type == BANO_SOCKET_TYPE_HTTPD)
{
msg = &httpd_msg;
handle_msg = handle_httpd_msg;
}
#endif /* BANO_CONFIG_HTTPD */
else
{
BANO_PERROR();
return 0;
}
err = bano_socket_read(socket, msg);
if (err == -2)
{
/* msg partially filled, redo select */
return 0;
}
if (err)
{
BANO_PERROR();
bano_socket_free(socket, prwmd->base);
bano_list_del(&prwmd->base->sockets, li);
return 0;
}
handle_msg(prwmd, socket, msg);
return 0;
}
int
loop()
{
/* receive events */
while(1) {
il_octet_string_t *msg;
long offset;
int ret;
do_handle_signal();
if(killflg)
return (0);
clear_error();
if((ret = input_queue_get(&msg, &offset, INPUT_TIMEOUT)) < 0)
{
if(error_get_maj() == IL_PROTO) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG,
" premature EOF while receiving event");
/* problems with socket input, try to catch up from files */
#ifndef PERF_EMPTY
event_store_recover_all();
#endif
continue;
} else
return(-1);
}
else if(ret == 0) {
continue;
}
#ifdef PERF_EMPTY
glite_wll_perftest_consumeEventString(msg->data);
free(msg->data);
continue;
#endif
#ifdef INTERLOGD_HANDLE_CMD
ret = handle_cmd(msg, offset);
if(ret == 0)
#endif
ret = handle_msg(msg, offset);
if(msg->data) free(msg->data);
if(ret < 0)
switch (error_get_maj()) {
case IL_SYS:
case IL_NOMEM:
return (ret);
break;
default:
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_ERROR,
"Error: %s",
error_get_msg());
break;
}
} /* while */
}
static ssize_t read_data(struct qmi_device *qmid){
ssize_t numbytes;
qmux_hdr_t *qmux_hdr;
//First, read a qmux header then read the data
//TODO: Consider something more efficient than two reads. A circular buffer
//for example.
if(!qmid->cur_qmux_length){
numbytes = read(qmid->qmi_fd, qmid->buf + qmid->qmux_progress,
sizeof(qmux_hdr_t));
if(numbytes == -1){
if(qmid_verbose_logging >= QMID_LOG_LEVEL_1)
QMID_DEBUG_PRINT(stderr, "Read from device failed\n");
return numbytes;
} else if(numbytes != sizeof(qmux_hdr_t)){
if(qmid_verbose_logging >= QMID_LOG_LEVEL_3)
QMID_DEBUG_PRINT(stderr, "Parial QMUX, length %zd\n", numbytes);
qmid->qmux_progress += numbytes;
} else {
qmux_hdr = (qmux_hdr_t*) qmid->buf;
qmid->qmux_progress = sizeof(qmux_hdr_t);
//+1 is for the marker, which is also part of the data I want to
//read
qmid->cur_qmux_length = le16toh(qmux_hdr->length) + 1;
//Add check for too large qmux length
}
}
//If I have received a full header, try to read data. This might happen
//immediatly
if(qmid->cur_qmux_length){
numbytes = read(qmid->qmi_fd, qmid->buf + qmid->qmux_progress,
qmid->cur_qmux_length - qmid->qmux_progress);
if(numbytes == -1){
if(qmid_verbose_logging >= QMID_LOG_LEVEL_1)
QMID_DEBUG_PRINT(stderr, "Read from device failed\n");
return numbytes;
}
qmid->qmux_progress += numbytes;
if(qmid->qmux_progress == qmid->cur_qmux_length){
handle_msg(qmid);
qmid->qmux_progress = 0;
qmid->cur_qmux_length = 0;
}
}
return numbytes;
}
//���������������������������������������������������������������������������
// TurnerClassic - receive
//���������������������������������������������������������������������������
int TurnerClassic::receive ()
{
DPID from, to;
HRESULT res;
DWORD size;
if (!pIDP)
return DPERR_UNAVAILABLE;
if (!rbuffer)
{
rbuffer = new char[TURNER_INIT_BUFFER];
if (!rbuffer)
return DPERR_OUTOFMEMORY;
rbsize = TURNER_INIT_BUFFER;
}
for(;;)
{
Sleep(0);
res = pIDP->Receive (&from, &to,
DPRECEIVE_ALL,
rbuffer, (LPDWORD)&size);
switch (res)
{
case DPERR_BUFFERTOOSMALL:
if (size > TURNER_MAX_BUFFER)
return DPERR_SENDTOOBIG;
delete [] rbuffer;
while (rbsize < size)
rbsize *= 2;
rbuffer = new char[rbsize];
if (!rbuffer)
return DPERR_OUTOFMEMORY;
break;
case DP_OK:
if (!from)
handle_sysmsg (to, (DPMSG_GENERIC *)rbuffer, size);
else
handle_msg (from, to, rbuffer, size);
return DP_OK;
default:
return res;
}
}
}
bool DataFlashFileReader::update(char type[5])
{
uint8_t hdr[3];
if (read_input(hdr, 3) != 3) {
return false;
}
if (hdr[0] != HEAD_BYTE1 || hdr[1] != HEAD_BYTE2) {
printf("bad log header\n");
return false;
}
if (hdr[2] == LOG_FORMAT_MSG) {
struct log_Format f;
memcpy(&f, hdr, 3);
if (read_input(&f.type, sizeof(f)-3) != sizeof(f)-3) {
return false;
}
memcpy(&formats[f.type], &f, sizeof(formats[f.type]));
strncpy(type, "FMT", 3);
type[3] = 0;
message_count++;
return handle_log_format_msg(f);
}
if (!done_format_msgs) {
done_format_msgs = true;
end_format_msgs();
}
const struct log_Format &f = formats[hdr[2]];
if (f.length == 0) {
// can't just throw these away as the format specifies the
// number of bytes in the message
::printf("No format defined for type (%d)\n", hdr[2]);
exit(1);
}
uint8_t msg[f.length];
memcpy(msg, hdr, 3);
if (read_input(&msg[3], f.length-3) != f.length-3) {
return false;
}
strncpy(type, f.name, 4);
type[4] = 0;
message_count++;
return handle_msg(f,msg);
}
int main(int argc, char* argv[]){
//printf("argc:%d arg1:%s\n", argc, argv[1]);
clr_connections(srv_state);
clr_connections(dirty_state);
int cont =1;
next_fid =0;
struct sigaction act;
act.sa_handler = (update_clients_handler);
if(sigaction(SIGALRM, &act, NULL)){
printf("error setting alarm handler\n");
}
struct timeval tv;
//kill(getpid(), SIGVTALRM);
tv.tv_sec=0;
tv.tv_usec = TIC_RATE;
const struct itimerval it_update = {tv, tv};
if(setitimer(ITIMER_REAL, &it_update, NULL)) perror("setitimer failure");
openfd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(HOST_PORT);
bind(openfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr_in));
while(cont){
struct client_data new_client;
int socklen = sizeof(struct sockaddr_in);
if(recvfrom(openfd, &new_client, sizeof(struct client_data), 0, (struct sockaddr*)&new_client.destaddr, &socklen)!=0){
printf("recieved msg. client_id=%d, address=%s\n", new_client.client_id, inet_ntoa(new_client.destaddr.sin_addr));
if(new_client.client_id>-1){
if(handle_msg(&new_client, dirty_state, openfd)){
printf("error handle_msg()\n");
return -1;
}
}
else{
if(handle_new_client(&new_client, dirty_state, openfd)){
printf("error handle_msg()\n");
return -1;
}
}
}
}
return 0;
}
void do_read_body(Header header){
auto self(shared_from_this());
buf_ptr buf_ptr_(new EasyBuffer);
buf_ptr_->prepare(sizeof(Header) + header.body_size);
memcpy(buf_ptr_->get_buffer(), &header, sizeof(Header));
boost::asio::async_read(socket_, boost::asio::buffer(buf_ptr_->get_buffer(sizeof(Header)), header.body_size),
[this, self, &buf_ptr_](boost::system::error_code ec, std::size_t){
if(!ec){
handle_msg(buf_ptr_);
do_read_header();
}
}
);
}
void ClientConnection::on_read(const boost::system::error_code &err, size_t bytes) {
if (err) {
BOOST_LOG_TRIVIAL(error) << "on_read error: " << err << " client id=" << _id;
throw server_exception("on_read error", shared_from_this());
}
std::string msg(_read_buffer, bytes);
BOOST_LOG_TRIVIAL(info) << "Received from client id=" << _id << " msg: " << msg;
if (_need_stop) {
_need_stop = false;
do_write("stop\n", boost::bind(&ClientConnection::on_write_disconnected, shared_from_this(), _1, _2));
}
else {
handle_msg(msg);
}
}
int MsgTask::svc (void)
{
Message * m =0 ;
while (!stop_)
{
if ( get_msg(m) == 0)
{
assert(m);
(void) handle_msg(*m);
delete m;
}
}
return 0;
}
void on_receive(struct moag *m, ENetEvent *ev)
{
struct chunk_header *chunk;
chunk = receive_chunk(ev->packet);
intptr_t id = (intptr_t)ev->peer->data;
switch (chunk->type)
{
case INPUT_CHUNK:
{
struct input_chunk *input = (void *)chunk;
switch (input->key)
{
case KLEFT_PRESSED: m->players[id].kleft = true; break;
case KLEFT_RELEASED: m->players[id].kleft = false; break;
case KRIGHT_PRESSED: m->players[id].kright = true; break;
case KRIGHT_RELEASED: m->players[id].kright = false; break;
case KUP_PRESSED: m->players[id].kup = true; break;
case KUP_RELEASED: m->players[id].kup = false; break;
case KDOWN_PRESSED: m->players[id].kdown = true; break;
case KDOWN_RELEASED: m->players[id].kdown = false; break;
case KFIRE_PRESSED: m->players[id].kfire = true; break;
case KFIRE_RELEASED:
{
uint16_t power = input->ms;
m->players[id].kfire = false;
m->players[id].tank.power = power / 2;
m->players[id].tank.power = CLAMP(0, 1000, m->players[id].tank.power);
break;
}
}
break;
}
case CLIENT_MSG_CHUNK:
{
struct client_msg_chunk *client_msg = (void *)chunk;
handle_msg(m, id, (char *)client_msg->data, ev->packet->dataLength - 1);
break;
}
default: break;
}
free(chunk);
}
void NativeChannel::handle_read_body(const boost::system::error_code& error)
{
if (!error)
{
handle_msg(read_msg_);
boost::asio::async_read(serverSocket,
boost::asio::buffer(read_msg_.data(), Message::header_length),
boost::bind(&NativeChannel::handle_read_header, this,
boost::asio::placeholders::error));
}
else
{
Logger::log("Channel( " + me.to_log_string() + "error when reading message body: " + error.message());
m_IsConnected = false;
do_close();
}
}
int main(int cgc_argc, char *cgc_argv[])
{
uint8_t *data = NULL;
cgc_init_vault();
cgc_store_in_vault(0, (void *)cgc_handlers, sizeof(cgc_handlers));
while (1)
{
uint8_t msg[6], *newdata;
uint16_t id;
uint32_t len;
if (cgc_read_bytes(&msg[0], 4) == 0)
break;
id = betoh16(*(uint16_t *)&msg[0]);
len = betoh16(*(uint16_t *)&msg[2]);
if (len & 0x8000)
{
if (cgc_read_bytes(&msg[4], 2) == 0)
break;
len = betoh32(*(uint32_t *)&msg[2]) & 0x7fffffff;
}
if (!is_supported(id))
{
ignore:
if (consume_bytes(len) == 0)
break;
continue;
}
newdata = cgc_realloc(data, len);
if (newdata == NULL)
goto ignore;
data = newdata;
if (cgc_read_bytes(data, len) == 0)
break;
handle_msg(id, data, len);
}
cgc_free(data);
return 0;
}
int main(int argc, char**argv)
{
int sockfd,n_bytes;
struct sockaddr_in servaddr,cliaddr;
char recvline[MAX_RX_BUF];
int quit = 0, flag = 1;
if (argc != 2)
{
printf("usage: robot <IP address>\n");
exit(1);
}
sockfd=socket(AF_INET,SOCK_STREAM,0);
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)); // disable Naggle algorithm
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr=inet_addr(argv[1]);
servaddr.sin_port=htons(10000);
connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
while(!quit) {
n_bytes = recv(sockfd, recvline, sizeof(recvline) - 1, 0);
if (n_bytes == -1) {
// Socket in error state
return 0;
} else if (n_bytes == 0) {
// Socket has been closed
fprintf (stderr, "Socket %d closed", sockfd);
close(sockfd);
return 0;
} else {
// let's process it
recvline[n_bytes] = '\0';
printf ("Received %s\n", recvline);
quit = handle_msg(recvline, sockfd);
}
}
return 0;
}
int handle_proc_req(int socket)
{
int ret;
struct timeval timeout;
unix_domain_msg *msg = NULL;
char msg_buf[MAX_BUF_SIZE] = { 0 };
msg = (unix_domain_msg *)msg_buf;
timeout.tv_sec = 3;
timeout.tv_usec = 0;
ret = unix_domain_recv_msg(socket, msg, MAX_BUF_SIZE, &timeout);
if (ret != 0) {
fprintf(std_err, "recv_msg() failed.\n");
goto done;
}
ret = handle_msg((tl_timer_t *)msg->data);
if (ret != 0) {
fprintf(std_err, "handle_msg() failed.\n");
}
msg->size = sizeof(tl_timer_t);
ret = unix_domain_send_msg(socket, (void *)msg, sizeof(unix_domain_msg) + msg->size, &timeout);
if (ret != 0) {
fprintf(std_err, "send_msg() failed.\n");
}
done:
if ((void *)msg != (void *)msg_buf) {
free(msg);
msg = NULL;
}
if (socket >= 0) {
close(socket);
}
return (ret);
}
static void
nub_rcv( int fd, int dummy_events )
{
struct pollfd ufds;
mol_dgram_t *dg;
int err, events;
/* the events parameter can not be trusted since a queued async events can
* be stolen by a debugger_nub_poll() call.
*/
ufds.fd = fd;
ufds.events = POLLHUP | POLLIN | POLLERR;
if( poll(&ufds, 1, 0) <= 0 )
return;
events = ufds.revents;
if( events & POLLHUP ) {
if( sv.hup_count++ > 0 ) {
sv.hup_count = 0;
printm("Debugger connection lost\n");
close_sock();
}
return;
}
if( events & ~POLLIN ) {
fprintf(stderr, "nub_rcv events %x\n", events );
return;
}
if( sv.dgram_receiver ) {
if( (dg=receive_dgram(sv.dgram_receiver, &err)) ) {
handle_msg(dg);
free(dg);
} else if( err ) {
printm("nub_rcv: an error occured\n");
}
} else {
printm("Unexpected nub_rcv\n");
}
}
/*
* RUN()
* run() to start the epoll_server
* param time_out is to wait running epoll_wait once
* determine what the m_epoll_events[i].data.fd equals
* 1. if it equals listen sock fd, then do accept_new_client()
* 2. if it equals client sock fd, and the property is EPOLLIN,
* then recv_data() from client
* 3. if it equals client sock fd, and the property is EPOLLOUT,
* then send_data() to client
*/
void epoll_server::run(int time_out)
{
while (1) {
int ret = epoll_server_wait(time_out);
if (ret == 0) {
continue;
} else if (ret == -1) {
cout << "epoll wait error: " << strerror(errno)
<< "(errno: " << errno << ")" << endl;
continue;
} else {
for (int i = 0; i < ret; ++i) {
if (m_epoll_events[i].data.fd == m_listen_sock) {
accept_new_client();
} else {
handle_msg(m_epoll_events[i].data.fd);
}
}
}
}
}
static int peek_msg(bano_list_item_t* li, void* p)
{
bano_socket_t* const socket = li->data;
struct prw_msg_data* const prwmd = p;
#ifdef BANO_CONFIG_HTTPD
bano_httpd_msg_t httpd_msg;
#endif /* BANO_CONFIG_HTTPD */
bano_msg_t bano_msg;
void* msg;
msg_handler_t handle_msg;
if (socket->type == BANO_SOCKET_TYPE_SNRF)
{
msg = &bano_msg;
handle_msg = handle_bano_msg;
}
#ifdef BANO_CONFIG_HTTPD
else if (socket->type == BANO_SOCKET_TYPE_HTTPD)
{
msg = &httpd_msg;
handle_msg = handle_httpd_msg;
}
#endif /* BANO_CONFIG_HTTPD */
else
{
BANO_PERROR();
return 0;
}
while (bano_socket_peek(socket, msg) == 0)
{
handle_msg(prwmd, socket, msg);
}
return 0;
}
int16 main(void)
{
GRECT n = {0,0,0,0};
GRECT r1;
EVNTDATA ev;
int16 bclicks, bmask, bstate;
boolean leave;
quit = FALSE;
debug_init("MControl", null, NULL);
init_app("mcontrol.rsc");
init_rsrc();
init_conf();
init_dial();
init_comm();
init_beta();
/* Callback f�r modale Fensterdialoge, Fenster-Alerts usw. */
set_mdial_wincb(handle_msg);
graf_mkstate( &ev );
wdial_hover( ev.x, ev.y, &r1, &leave );
while (!quit)
{
mbutton = 0;
if( !((ev.bstate) & 3) )
bclicks = 258;
else
bclicks = 0;
bmask = 3;
bstate = 0;
event = evnt_multi( MU_BUTTON|MU_M1|MU_MESAG|MU_KEYBD,
bclicks, bmask, bstate,
leave, &r1, 0, &n,
msg,
0l,
&ev,
&kreturn, &mclick );
msx = ev.x;
msy = ev.y;
mbutton = ev.bstate;
kstate = ev.kstate;
if (event & MU_MESAG)
{
if( msg[0] == WM_MOVED )
wdial_hover( msx, msy, &r1, &leave );
handle_msg(msg);
}
if (event & MU_BUTTON)
{
if( mbutton == 2 )
menu_context( msx, msy );
else if (!click_wdial(mclick, msx, msy, kstate, mbutton))
;
}
if (event & MU_M1)
wdial_hover( msx, msy, &r1, &leave );
if (event & MU_KEYBD)
{
int16 title, item;
if (is_menu_key(kreturn, kstate, &title, &item))
handle_menu(title, item);
else
{
key_wdial(kreturn, kstate);
key_sdial(kreturn, kstate);
}
}
}
exit_comm();
exit_dial();
exit_rsrc();
debug_exit();
exit_app(0);
return 0;
}
int main(int argc, char *argv[]) {
char *str;
int i = 0, day = 0, hour = 4;
umask(027);
lockfd = open(MY_BBS_HOME "/friends.lock", O_CREAT | O_RDONLY, 0660);
if (flock(lockfd, LOCK_EX | LOCK_NB) < 0)
exit(1);
if(argc == 2) {
if(!strcmp(argv[1], "-d")) { //run as daemon
if (fork())
return 0;
setsid();
if (fork())
return 0;
close(0);
close(1);
close(2);
}
}
msqid = initFriendsMSQ();
if (msqid < 0)
exit(1);
fidx = ght_create(MAXUSERS + 3);
if (fidx == NULL)
exit(1);
mkdir(FRIENDS_TMPDIR, 0770); //try making tmp dir
if(load_friends() == -1)
exit(1);
div_friends();
friends_top10();
signal(SIGHUP, set_sync_flag); //sync if disconnected
signal(SIGTERM, write_back_all);
signal(SIGCHLD, sig_child);
while (1) {
while ((str = rcvlog(msqid, 1))) {
// printf("%s\n", str);
handle_msg(str);
}
sleep(5);
i++;
if (i == hour*12*60 || sync_flag) { //write back from time to time
system("rm -f " FRIENDS_TMPDIR "/*");
if(++day == 24/hour) {//daily
day = 0;
estrange_by_time();
}
save_friends();
div_friends();
friends_top10();
i = 0;
sync_flag = 0;
}
}
return 0;
}
void IRC::handle(const string& oline) {
string line = trim(oline);
printf("%s\n", line.c_str());
//We are pinged, respond!
if(line.compare(0, 4, "PING") == 0) {
onServerPing(line.substr(5));
return;
}
char* cstr = new char[line.size() + 1];
strcpy(cstr, line.c_str());
string sender, nick, login, host;
bool nickOnly = false;
size_t tokn = 0;
char *tok = strtok(cstr, " ");
while(tok != NULL) {
//For each token, check
string tmp = tok;
if(tokn == 0) {
sender = tmp;
if(sender[0] == ':')
sender = sender.substr(1);
size_t exp = sender.find("!");
size_t at = sender.find("@");
//TODO: Add checks for 'exp' and 'at' being string::npos
// to avoid calling these when there are (no ill effects
// have been seen from not doing so yet, however for sanity sake)
if(exp == string::npos || at == string::npos) {
nick = trim(sender);
login = "";
host = "";
nickOnly = true;
} else {
nick = trim(sender.substr(0, exp));
login = trim(sender.substr(exp + 1, at));
host = trim(sender.substr(at + 1));
}
}
if(tokn == 1) {
tok = strtok(NULL, " ");
string target(tok); //AKA channel
uint32_t code = 0;
if(tmp.length() == 3 && (code = (uint32_t) atoi(tmp.c_str())) != 0 && code < 1000) {
string response = line.substr(sender.length()+5+target.length()+1);
handle_numeric(code,target,response);
onNumeric(sender,code,target,response);
} else if(tmp.compare("PRIVMSG") == 0) {
handle_msg(target, nick, login, host, line.substr(line.find(" :") + 2));
} else if(tmp.compare("NOTICE") == 0) {
onNotice(target, nick, login, host, line.substr(line.find(" :") + 2));
} else if(tmp.compare("JOIN") == 0) {
//TODO: Add this user to the channel.
onJoin(target, nick, login, host);
} else if(tmp.compare("PART") == 0) {
//TODO: Remove this user from the channel.
onPart(target, nick, login, host);
} else if(tmp.compare("TOPIC") == 0) {
onTopic(target, line.substr(line.find(" :") + 2), nick, time(NULL), true);
} else if(tmp.compare("KICK") == 0) {
tok = strtok(NULL, " ");
string recipient(tok);
onKick(target, nick, login, host, recipient, line.substr(line.find(" :") + 2));
} else if(tmp.compare("QUIT") == 0) {
onQuit(nick, login, host, line.substr(line.find(" :") + 2));
} else if(tmp.compare("MODE") == 0) {
tok = strtok(NULL, " ");
string mode = tok;
if(mode[0] == ':')
mode = mode.substr(1);
handle_mode(nick, login, host, target, mode);
}
//TODO: Add mode handler here
else {
onUnknown(line);
}
break;
}
tok = strtok(NULL, " ");
++tokn;
}
delete[] cstr;
}
static uint8_t do_uart(void)
{
/* return 0 if no msg processed, 1 otherwise */
/* note: commands comming from the host always */
/* require a form of ack, which implies that */
/* there wont be a uart rx burst from the dev */
/* point of view. thus, this routine can be */
/* slow to handle message without missing */
/* bytes, until the reply is sent. */
/* no need to disable interrupts. cf USART_RX_vect comment. */
const uint8_t pos = uart_pos;
uint8_t x;
if (pos != sizeof(snrf_msg_t))
{
/* not a full message available */
return 0;
}
/* synchronization procedure */
if (uart_buf[offsetof(snrf_msg_t, sync)] == SNRF_SYNC_BYTE)
{
/* disable interrupts before setting uart_pos */
/* with interrupts disabled, wait for SYNC_END */
cli();
uart_pos = 0;
while (1)
{
/* do not stop on error during sync */
if (uart_read_uint8(&x)) continue ;
if (x == SNRF_SYNC_END) break ;
}
sei();
/* set state to conf */
if (snrf_state != SNRF_STATE_CONF)
{
snrf_state = SNRF_STATE_CONF;
nrf_set_powerdown_mode();
}
return 1;
}
/* handle new message */
handle_msg((snrf_msg_t*)uart_buf);
/* warning: set uart_pos to 0 before sending */
/* the reply, since the host will start sending */
/* new packets and we do not want the interrupt */
/* handler to see uart_buf full */
uart_pos = 0;
/* send completion */
uart_write((uint8_t*)uart_buf, sizeof(snrf_msg_t));
/* a message has been handled */
return 1;
}
