void create() {
unsigned int index;
unsigned int count;
char buf[20];
puts("input index");
index = get_index();
if (index < 0 || index > 8) {
puts("invalid index");
return;
}
if (note[index].content) {
puts("this item has been used");
return;
}
puts("input size");
read_wrapper(buf, 20);
note[index].size = atol(buf);
note[index].content = (long)malloc(note[index].size);
puts("now input your secret");
count = read_wrapper((char *)(note[index].content), note[index].size);
((char *)(note[index].content))[count] = '\0';
note[index].content ^= key;
puts("note added");
return;
}
/**
* @brief read a message from an open file desctriptor.
* @param fd the file desctriptor to read from
* @returns a pointer to the readed message, or NULL on error.
*/
message *read_message(int fd) {
struct message *res;
res = malloc(sizeof(struct message));
if(!res) {
print( ERROR, "malloc: %s", strerror(errno) );
return NULL;
}
memset(res, 0, sizeof(struct message));
if(!read_wrapper(fd, &(res->head), sizeof(struct msg_header))) {
if(res->head.size) {
res->data = read_chunk(fd, res->head.size);
if(res->data) {
#ifndef NDEBUG
print( DEBUG, "received a message (fd=%d)", fd );
dump_message(res);
#endif
return res;
}
} else {
print( ERROR, "received a 0-length message" );
dump_message(res);
}
}
free(res);
return NULL;
}
static int
select_read_wrapper(handle_t fd , struct timeval * time)
{
fd_set rdfs;
unsigned char byte;
int ret;
FD_ZERO( &rdfs );
FD_SET(fd , &rdfs);
ret = select( fd+1, &rdfs, NULL, NULL, time);
if (ret<0) {
fprintf(stderr, "select_read_wrapper:: error during select: %s (%i)\n",
strerror(errno) ,errno);
return ATMELLIB_ERROR_NORESPVAL;
}
else if (ret==0) {
// time expired
fprintf(stderr, "vrpn_atmellib::select_read_wrapper: select timed out\n" );
return ATMELLIB_ERROR_NORESPVAL;
}
// successful select -> read out one command
if ((ret = read_wrapper(fd , (void *) (&byte), 1)) <=0 )
return ret;
#ifdef VRPN_ATMELLIB_VERBOSE_OUTBIT
outBit(byte);
#endif
return byte;
}
int
process_server( int sockfd_new )
{
while(1)
{
fd_set readfd;
FD_ZERO(&readfd);
FD_SET(sockfd_new ,&readfd);
struct timeval tv;
tv.tv_sec = TIME_OUT_DEFAULT;
tv.tv_usec = 0;
if( select(sockfd_new+1, &readfd, NULL, NULL, &tv) < 0 )
{
if( EINTR == errno )
{
continue;
}
SERVER_DEBUG( "select error:%s\n", strerror(errno) );
return -1;
} else if( FD_ISSET(sockfd_new, &readfd) ) {
char buffer[SO_BUF_LEN_MAX];
memset( buffer, 0, sizeof(buffer) );
SERVER_DEBUG( "receive message:\n" );
ssize_t length = 0;
if( ( length = read_wrapper(sockfd_new, buffer, sizeof(buffer)) ) < 0 )
{
SERVER_DEBUG( "read error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "read size = %d\n", length );
if( 0 < length )
{
SERVER_DEBUG( "send message:\n" );
const char* message = get_time_string();
if( ( length = write_wrapper( sockfd_new, message, strlen(message) ) ) < 0 )
{
SERVER_DEBUG( "write error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "write size = %d\n", length );
} else {
SERVER_DEBUG( "read error, close socket\n" );
return -1;
}
} else {
continue;
}
}
kill( parent, SIGCHLD );
return 0;
}
int read_all(int fd, void *buf, size_t count) {
ssize_t read_bytes;
while (count > 0) {
read_bytes = read_wrapper(fd, buf, count);
if (read_bytes <= 0) return -1;
buf += read_bytes;
count -= read_bytes;
}
return 0;
}
ssize_t socket_read(int socket_fd, char** buffer, size_t length) {
ssize_t nread;
nread = read_wrapper(socket_fd, *buffer, length);
if (nread == -1) {
fprintf(stderr, "Read failed.\n");
return -1;
}
#if DEBUG
printf("Received %d bytes\n", nread);
#endif
return nread;
}
void edit() {
unsigned int index;
unsigned int count;
puts("input index");
index = get_index();
if (index < 0 || index > 8) {
puts("invalid index");
return;
}
if (!note[index].content) {
puts("this item is unused");
return;
}
puts("now you can edit your secret");
count = read_wrapper((char *)(note[index].content ^ key), note[index].size);
((char *)(note[index].content ^ key))[count] = '\0';
puts("edited");
return;
}
int
process_http_proxy( int sockfd_new )
{
while(1)
{
fd_set readfd;
FD_ZERO(&readfd);
FD_SET(sockfd_new, &readfd);
struct timeval tv;
tv.tv_sec = TIME_OUT_DEFAULT;
tv.tv_usec = 0;
if( select(sockfd_new+1, &readfd, NULL, NULL, &tv) < 0 )
{
if( EINTR == errno )
{
continue;
}
SERVER_DEBUG( "select error:%s\n", strerror(errno) );
return -1;
} else if( FD_ISSET(sockfd_new, &readfd) ) {
char buffer[SO_BUF_LEN_MAX];
SERVER_DEBUG( "receive downstream message:\n" );
ssize_t length = 0;
if( ( length = read_wrapper(sockfd_new, buffer, sizeof(buffer)) ) < 0 )
{
SERVER_DEBUG( "read error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "read size = %d \n", length );
if( length > 0 )
{
//to do
buffer[length] = '\0';
//parse http_data
char host_ip[HOST_IP_LEN_MAX] = {0};
if( parse_http_data( buffer, length, host_ip, sizeof(host_ip) ) < 0 )
{
SERVER_DEBUG( "parse_http_data error\n" );
return -1;
} else {
int sockfd = 0;
if( ( sockfd = initial_socket() ) < 0 )
{
SERVER_DEBUG( "initial_socket error\n" );
return -1;
}
struct sockaddr_in client_addr;
memset( &client_addr, 0, sizeof(client_addr) );
client_addr.sin_family = AF_INET;
client_addr.sin_port = htons(HOST_PORT_DEFAULT);
inet_pton( AF_INET, host_ip, &client_addr.sin_addr );
if( connect( sockfd, (struct sockaddr*)&client_addr, sizeof(client_addr) ) < 0 )
{
SERVER_DEBUG( "client connect %s:%d error:%s\n", host_ip, HOST_PORT_DEFAULT, strerror(errno) );
close( sockfd );
return -1;
} else {
SERVER_DEBUG( "connect successfully %s:%d \n", host_ip, HOST_PORT_DEFAULT );
if( setsockopt_nonblock(sockfd) < 0 )
{
SERVER_DEBUG( "setsockopt_nonblock error\n" );
close( sockfd );
return -1;
}
SERVER_DEBUG( "send message to upsteam:\n" );
if( ( length = write_wrapper( sockfd, buffer, length ) ) == -1 )
{
SERVER_DEBUG( "write error:%s\n", strerror(errno) );
close( sockfd );
return -1;
}
SERVER_DEBUG( "write size = %d\n", length );
while(1)
{
FD_ZERO(&readfd);
FD_SET(sockfd_new, &readfd);
FD_SET(sockfd ,&readfd);
tv.tv_sec = TIME_OUT_DEFAULT;
tv.tv_usec = 0;
if( select(sockfd+1, &readfd, NULL, NULL, &tv) < 0 )
{
if( EINTR == errno )
{
continue;
}
SERVER_DEBUG( "select error:%s\n", strerror(errno) );
return -1;
} else if( FD_ISSET(sockfd, &readfd) ) {
SERVER_DEBUG( "receive upstream message:\n" );
if( data_exchange( sockfd_new, sockfd, buffer, sizeof(buffer) ) < 0)
{
SERVER_DEBUG( "data_exchange error\n" );
close( sockfd );
return -1;
}
} else if( FD_ISSET(sockfd_new, &readfd) ) {
SERVER_DEBUG( "receive downstream message:\n" );
if( data_exchange( sockfd, sockfd_new, buffer, sizeof(buffer) ) < 0)
{
SERVER_DEBUG( "data_exchange error\n" );
close( sockfd );
return -1;
}
} else {
SERVER_DEBUG( "receive upstream message timeout\n" );
continue;
} //select timeout
} //while(1)
} //connect
} //parse_http_data
} else { //read_wrapper <= 0
SERVER_DEBUG( "receive downstream message error, client socket closed\n" );
return -1;
}
} else { //select timeout
SERVER_DEBUG( "receive downstream message timeout\n" );
}
}
kill( parent, SIGCHLD );
return 0;
}
int epoll_server( int sockfd )
{
#define EVENTS_MAX 100
int epfd = epoll_create( EVENTS_MAX );
if( epfd < 0 )
{
SERVER_DEBUG( "epoll_create error:%s\n", strerror( errno ) );
return -1;
}
struct epoll_event epollev;
epollev.events = EPOLLIN;
epollev.data.fd = sockfd;
if( epoll_ctl( epfd, EPOLL_CTL_ADD, sockfd, &epollev) < 0 )
{
SERVER_DEBUG( "epoll_ctl error:%s\n", strerror( errno ) );
close( epfd );
return -1;
}
struct epoll_event events[EVENTS_MAX];
int connection = 0;
while( 1 )
{
#define TIME_OUT 5000
int ret = epoll_wait( epfd, events, EVENTS_MAX, TIME_OUT );
SERVER_DEBUG( "epoll_wait ret:%d\n", ret );
if( ret < 0 )
{
SERVER_DEBUG( "epoll_wait error:%s\n", strerror( errno ) );
close( epfd );
//handle other fdes
return -1;
} else if( 0 == ret ) {
SERVER_DEBUG( "TIME_OUT,listenning...\n" );
continue;
} else {
int i = 0;
for( i = 0; i < ret; ++i )
{
if( events[i].data.fd == sockfd )
{
//accept new connection
int sockfd_new = handle_new_connection( sockfd );
if( sockfd_new < 0 )
{
SERVER_DEBUG( "handle_new_connection error\n" );
return -1;
}
//epollev.events = EPOLLIN|EPOLLOUT|EPOLLET;
epollev.events = EPOLLIN|EPOLLET;
epollev.data.fd = sockfd_new;
if( epoll_ctl( epfd, EPOLL_CTL_ADD, sockfd_new, &epollev) < 0 )
{
SERVER_DEBUG( "epoll_ctl error:%s\n", strerror( errno ) );
close( epfd );
return -1;
}
SERVER_DEBUG( "total connections:%d\n", ++connection );
} else {
//read-write
int sockfd = events[i].data.fd;
char buffer[SO_BUF_LEN_MAX];
memset( buffer, 0, sizeof(buffer) );
SERVER_DEBUG( "receive message:\n" );
ssize_t length = 0;
if( ( length = read_wrapper(sockfd, buffer, sizeof(buffer)) ) < 0 )
{
SERVER_DEBUG( "read error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "read size = %d\n", length );
if( 0 == length )
{
SERVER_DEBUG( "closing socket\n" );
epollev.data.fd = sockfd;
if( epoll_ctl( epfd, EPOLL_CTL_DEL, sockfd, &epollev) < 0 )
{
SERVER_DEBUG( "epoll_ctl error:%s\n", strerror( errno ) );
close( epfd );
return -1;
}
close( sockfd );
} else {
SERVER_DEBUG( "buffer:%s\n", buffer );
const char* message = get_time_string();
SERVER_DEBUG( "send message:%s\n", message );
if( ( length = write_wrapper( sockfd, message, strlen(message) ) ) < 0 )
{
SERVER_DEBUG( "write error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "write size = %d\n", length );
}
}
}
}
}
return 0;
}
/*!
\brief read_data() reads in the data from the ECU, checks to make sure
enough arrived, copies it to thedestination buffer and returns;
\param total_wanted if set to -1, input is variable and we don't error out.
otherwise error out if count doesn't match what is asked for
\param buffer is the pointer to buffer to stick the data.
\param reset_on_fail is a hacky flag that should be removed, (win32ism)
\returns TRUE on success, FALSE on failure
*/
G_MODULE_EXPORT gint read_data(gint total_wanted, guint8 **buffer, gboolean reset_on_fail)
{
static GMutex *serio_mutex = NULL;
static GMutex mutex;
static gint failcount = 0;
static gboolean reset = FALSE;
gboolean res = 0;
gint total_read = 0;
gint zerocount = 0;
gint len = 0;
gboolean bad_read = FALSE;
guchar buf[4096];
guchar *ptr = buf;
gboolean ignore_errors = FALSE;
Serial_Params *serial_params = NULL;;
serial_params = (Serial_Params *)DATA_GET(global_data,"serial_params");
ENTER();
if (!serio_mutex)
serio_mutex = (GMutex *)DATA_GET(global_data,"serio_mutex");
g_mutex_lock(&mutex);
total_read = 0;
zerocount = 0;
if (total_wanted == -1)
{
ignore_errors = TRUE;
total_wanted = 1024;
}
/* Werid windows issue. Occasional "short" reads, but nothing else
* comes in for some reason. So if that happens, double what's read
* next time and throw it away to get things back in sync.
* Ugly hack, but couldn't find out why it did it. might be due to
* excess latency in my test VM
*/
#ifdef __WIN32__
if (reset)
total_wanted *= 2;
#endif
g_mutex_lock(serio_mutex);
while ((total_read < total_wanted ) && ((total_wanted-total_read) > 0))
{
MTXDBG(IO_PROCESS,_("Requesting %i bytes\n"),total_wanted-total_read);
res = read_wrapper(serial_params->fd,
ptr+total_read,
total_wanted-total_read,&len);
total_read += len;
/* Increment bad read counter.... */
if (!res) /* I/O Error Device disappearance or other */
{
MTXDBG((Dbg_Class)(IO_PROCESS|CRITICAL),_("I/O ERROR: \"%s\"\n"),(gchar *)g_strerror(errno));
bad_read = TRUE;
DATA_SET(global_data,"connected",GINT_TO_POINTER(FALSE));
break;
}
if (len == 0) /* Short read!*/
zerocount++;
if ((len == 0) && (zerocount > 3)) /* Too many Short reads! */
{
bad_read = TRUE;
break;
}
MTXDBG(IO_PROCESS,_("Read %i bytes, running total %i\n"),len,total_read);
}
g_mutex_unlock(serio_mutex);
if ((bad_read) && (!ignore_errors))
{
MTXDBG((Dbg_Class)(IO_PROCESS|CRITICAL),_("Error reading from ECU\n"));
serial_params->errcount++;
if ((reset_on_fail) && (!reset))
reset = TRUE;
else
reset = FALSE;
failcount++;
/* Excessive failures triggers port recheck */
if (failcount > 10)
DATA_SET(global_data,"connected",GINT_TO_POINTER(FALSE));
}
else
{
failcount = 0;
reset = FALSE;
}
if (buffer)
*buffer = g_memdup(buf,total_read);
dump_output(total_read,buf);
g_mutex_unlock(&mutex);
EXIT();
return total_read;
}
unsigned int get_index() {
char c;
read_wrapper(&c, 1);
return (unsigned int)(c - 48);
}
