static void
test_multiple_queueing() {
message_queue *queue = create_message_queue();
assert_true( queue != NULL );
buffer *first_buf = alloc_buffer();
assert_true( enqueue_message( queue, first_buf ) );
assert_int_equal( queue->length, 1 );
buffer *deq_buf = dequeue_message( queue );
assert_true( deq_buf == first_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 0 );
first_buf = alloc_buffer();
assert_true( enqueue_message( queue, first_buf ) );
assert_int_equal( queue->length, 1 );
buffer *second_buf = alloc_buffer();
assert_true( enqueue_message( queue, second_buf ) );
assert_int_equal( queue->length, 2 );
deq_buf = dequeue_message( queue );
assert_true( deq_buf == first_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 1 );
buffer *third_buf = alloc_buffer();
assert_true( enqueue_message( queue, third_buf ) );
assert_int_equal( queue->length, 2 );
buffer *fourth_buf = alloc_buffer();
assert_true( enqueue_message( queue, fourth_buf ) );
assert_int_equal( queue->length, 3 );
deq_buf = dequeue_message( queue );
assert_true( deq_buf == second_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 2 );
deq_buf = dequeue_message( queue );
assert_true( deq_buf == third_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 1 );
deq_buf = dequeue_message( queue );
assert_true( deq_buf == fourth_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 0 );
assert_true( delete_message_queue( queue ) );
}
static void
test_foreach_message_queue() {
message_queue *queue = create_message_queue();
assert_true( queue != NULL );
buffer *first_buf = alloc_buffer();
append_string( first_buf, "first_buffer" );
assert_true( enqueue_message( queue, first_buf ) );
assert_int_equal( queue->length, 1 );
buffer *second_buf = alloc_buffer();
append_string( second_buf, "second_buffer" );
assert_true( enqueue_message( queue, second_buf ) );
assert_int_equal( queue->length, 2 );
buffer *third_buf = alloc_buffer();
append_string( third_buf, "third_buffer" );
assert_true( enqueue_message( queue, third_buf ) );
assert_int_equal( queue->length, 3 );
buffer *deq_buf = dequeue_message( queue );
assert_true( deq_buf == first_buf );
char *user_data = xstrdup( "user_data" );
count = 0;
foreach_message_queue( queue, test_foreach_message_queue_helper, user_data );
assert_int_equal( count, 2 );
xfree( user_data );
assert_true( delete_message_queue( queue ) );
}
static void
flush_send_queue( int fd, void *user_data ) {
UNUSED( fd );
UNUSED( user_data );
assert( send_queue != NULL );
assert( connection.fd >= 0 );
debug( "Flushing send queue ( length = %u ).", send_queue->length );
set_writable( connection.fd, false );
buffer *buf = NULL;
while ( ( buf = peek_message( send_queue ) ) != NULL ) {
ssize_t write_length = write( connection.fd, buf->data, buf->length );
if ( write_length < 0 ) {
if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
set_writable( connection.fd, true );
return;
}
error( "Failed to send a message to secure channel ( errno = %s [%d] ).",
strerror( errno ), errno );
return;
}
if ( ( size_t ) write_length < buf->length ) {
remove_front_buffer( buf, ( size_t ) write_length );
set_writable( connection.fd, true );
return;
}
buf = dequeue_message( send_queue );
free_buffer( buf );
}
}
int
flush_secure_channel( struct switch_info *sw_info ) {
assert( sw_info != NULL );
assert( sw_info->send_queue != NULL );
assert( sw_info->secure_channel_fd >= 0 );
buffer *buf;
ssize_t write_length;
while ( ( buf = peek_message( sw_info->send_queue ) ) != NULL ) {
write_length = write( sw_info->secure_channel_fd, buf->data, buf->length );
if ( write_length < 0 ) {
if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
return 0;
}
error( "Failed to send a message to secure channel ( errno = %s [%d] ).",
strerror( errno ), errno );
return -1;
}
if ( ( size_t ) write_length < buf->length ) {
remove_front_buffer( buf, ( size_t ) write_length );
return 0;
}
buf = dequeue_message( sw_info->send_queue );
free_buffer( buf );
}
return 0;
}
static void
test_enqueue_and_dequeue_message_queue() {
message_queue *queue = create_message_queue();
assert_true( queue != NULL );
buffer *enq_buf = alloc_buffer();
assert_true( enqueue_message( queue, enq_buf ) );
assert_int_equal( queue->length, 1 );
buffer *deq_buf = dequeue_message( queue );
assert_true( deq_buf == enq_buf );
free_buffer( deq_buf );
assert_int_equal( queue->length, 0 );
deq_buf = dequeue_message( queue );
assert_true( deq_buf == NULL );
assert_int_equal( queue->length, 0 );
assert_true( delete_message_queue( queue ) );
}
int
flush_secure_channel( struct switch_info *sw_info ) {
assert( sw_info != NULL );
assert( sw_info->send_queue != NULL );
assert( sw_info->secure_channel_fd >= 0 );
buffer *buf;
ssize_t write_length;
if ( sw_info->send_queue->length == 0 ) {
return 0;
}
set_writable( sw_info->secure_channel_fd, false );
writev_args args;
args.iov = xmalloc( sizeof( struct iovec ) * ( size_t ) sw_info->send_queue->length );
args.iovcnt = 0;
foreach_message_queue( sw_info->send_queue, append_to_writev_args, &args );
if ( args.iovcnt == 0 ) {
xfree( args.iov );
return 0;
}
write_length = writev( sw_info->secure_channel_fd, args.iov, args.iovcnt );
xfree( args.iov );
if ( write_length < 0 ) {
if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
set_writable( sw_info->secure_channel_fd, true );
return 0;
}
error( "Failed to send a message to secure channel ( errno = %s [%d] ).",
strerror( errno ), errno );
return -1;
}
if ( write_length == 0 ) {
return 0;
}
while ( ( buf = peek_message( sw_info->send_queue ) ) != NULL ) {
if ( write_length == 0 ) {
set_writable( sw_info->secure_channel_fd, true );
return 0;
}
if ( ( size_t ) write_length < buf->length ) {
remove_front_buffer( buf, ( size_t ) write_length );
set_writable( sw_info->secure_channel_fd, true );
return 0;
}
write_length -= ( ssize_t ) buf->length;
buf = dequeue_message( sw_info->send_queue );
free_buffer( buf );
}
return 0;
}
gint dequeue_cb(GtkWidget *treeview, GdkEventButton *event, gpointer data) {
GtkTreeIter iter;
GtkTreeSelection *select;
if(!(event->type == GDK_2BUTTON_PRESS && event->button == 1))
return FALSE; /* Double clicking on the list will dequeue that user's messages. */
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
if(gtk_tree_selection_get_selected(select, NULL, &iter))
dequeue_message(&iter);
return FALSE;
}
static bool
recv_message_from_secure_channel() {
assert( recv_queue != NULL );
if ( recv_queue->length == 0 ) {
return false;
}
buffer *message = dequeue_message( recv_queue );
handle_secure_channel_message( message ); // FIXME: handle error properly
free_buffer( message );
return true;
}
void status_draw(game_t *p_game)
{
int32_t diamonds = p_game->p_cur_level->diamonds_required - p_game->player.diamonds;
int32_t time_left = p_game->p_cur_level->time - ((vGetTickCount() - p_game->start_ticks) / 1000);
int16_t x_start;
int16_t y_start;
int i;
if (diamonds < 0)
diamonds = 0;
if (time_left < 0)
time_left = 0;
y_start = PLAYFIELD_HEIGHT;
x_start = -6;
/* FIXME! */
vSetForeColor(vRGB(0,128,0));
vFillRect(x_start, y_start+1, screen_w, screen_h);
vSetForeColor(vRGB(0,255,0));
vFillRect(x_start, y_start, screen_w, y_start);
/* Print the number of diamonds and bombs */
print_status_entry_with_symbol(p_game, 2, x_start + 8, y_start + 1,
p_game->pp_sprite_frames[FRAMES_DIAMOND], diamonds);
print_status_entry_with_symbol(p_game, 2, x_start + 8, y_start + 9,
p_game->pp_sprite_frames[FRAMES_BOMB], p_game->player.bombs);
for (i=0; i<METAL_MAX; i++)
{
if (p_game->player.keys[i])
vDrawObject(x_start + 64 + i*9, y_start + 1, p_game->pp_sprite_frames[FRAMES_IRON_KEY + i]);
}
print_status_entry(p_game, 3, PLAYFIELD_WIDTH-16, y_start + 2, time_left);
/* Display the queued messages */
if (queue.msgs[queue.front].p_str)
{
if (--queue.msgs[queue.front].countdown > 0)
game_draw_message(p_game, queue.msgs[queue.front].p_str);
else
dequeue_message(p_game, &queue);
}
}
static void
gdm_smartcard_extension_queue_message (GdmLoginExtension *login_extension,
GdmServiceMessageType type,
const char *text)
{
GdmSmartcardExtension *extension = GDM_SMARTCARD_EXTENSION (login_extension);
QueuedMessage *message = g_slice_new (QueuedMessage);
message->text = g_strdup (text);
message->type = type;
g_queue_push_tail (extension->priv->message_queue, message);
if (extension->priv->message_timeout_id == 0) {
dequeue_message (extension);
}
}
static void
gdm_fingerprint_extension_queue_message (GdmLoginExtension *login_extension,
GdmServiceMessageType type,
const char *text)
{
GdmFingerprintExtension *extension = GDM_FINGERPRINT_EXTENSION (login_extension);
QueuedMessage *message = g_slice_new (QueuedMessage);
message->text = g_strdup (text);
message->type = type;
g_queue_push_tail (extension->priv->message_queue, message);
if (extension->priv->message_timeout_id == 0) {
dequeue_message (extension);
}
}
static int check_for_msg(void *session, int id, void *buf, size_t size, size_t *bytes_read)
{
unsigned char *recv_buf = ((unsigned char *) buf) + *bytes_read;
size_t recv_buf_size = size - *bytes_read;
int result;
result = dequeue_message(id, recv_buf, recv_buf_size, session);
if (result == -1) {
set_last_error("Error in dequeue message");
return -1;
}
else if (result == 0) {
return 0;
}
else {
*bytes_read += result;
return result;
}
}
int
handle_messages_from_secure_channel( struct switch_info *sw_info ) {
assert( sw_info != NULL );
assert( sw_info->recv_queue != NULL );
int ret;
int errors = 0;
buffer *message;
while ( ( message = dequeue_message( sw_info->recv_queue ) ) != NULL ) {
ret = ofpmsg_recv( sw_info, message );
if ( ret < 0 ) {
error( "Failed to handle message to application." );
errors++;
}
}
return errors == 0 ? 0 : -1;
}
uint_t
receive_message(MBFCB *p_mbfcb, void *msg, bool_t *p_dspreq)
{
TCB *p_tcb;
uint_t msgsz;
if (p_mbfcb->smbfcnt > 0) {
msgsz = dequeue_message(p_mbfcb, msg);
*p_dspreq = messagebuf_signal(p_mbfcb);
return(msgsz);
}
else if (!queue_empty(&(p_mbfcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mbfcb->swait_queue));
msgsz = ((WINFO_MBF *)(p_tcb->p_winfo))->msgsz;
memcpy(msg, ((WINFO_MBF *)(p_tcb->p_winfo))->msg, msgsz);
*p_dspreq = wait_complete(p_tcb);
return(msgsz);
}
else {
return(0U);
}
}
static int
flush_secure_channel_tls( struct switch_info *sw_info ) {
assert( sw_info != NULL );
assert( sw_info->tls );
assert( sw_info->ssl != NULL );
assert( sw_info->send_queue->length > 0 );
buffer *buf = NULL;
while ( ( buf = peek_message( sw_info->send_queue ) ) != NULL ) {
int write_length = SSL_write( sw_info->ssl, buf->data, ( int ) buf->length );
if ( write_length < 0 ) {
int error_no = SSL_get_error( sw_info->ssl, write_length );
switch ( error_no ) {
case SSL_ERROR_WANT_READ:
set_readable( sw_info->secure_channel_fd, true );
case SSL_ERROR_WANT_WRITE:
set_writable( sw_info->secure_channel_fd, true );
return 0;
default:
error( "Failed to send a message to secure channel ( error = %d ).", error_no );
return -1;
}
}
if ( write_length == 0 ) {
set_writable( sw_info->secure_channel_fd, true );
return 0;
}
if ( ( size_t ) write_length < buf->length ) {
remove_front_buffer( buf, ( size_t ) write_length );
set_writable( sw_info->secure_channel_fd, true );
return 0;
}
buf = dequeue_message( sw_info->send_queue );
free_buffer( buf );
}
return 0;
}
static void
test_dequeue_message_if_queue_is_not_created() {
message_queue *queue = NULL;
expect_assert_failure( dequeue_message( queue ) );
}
int
main(int argc, char **argv)
{
/*****************test 1********************************/
message_queue *tmp_queue;
if((tmp_queue = create_message_queue()) == NULL)
{
printf("create queue error!\n");
return -1;
}
int i = 1;
buffer *tmp_buf;
char *tmp_char;
tmp_char = *sample_string;
while( tmp_char != NULL )
{
tmp_buf = alloc_buffer_with_length(10);
strcpy(tmp_buf->data, tmp_char);
printf("the insert is %s, and %d\n",(char*)tmp_buf->data,sizeof(*(tmp_buf->data)));
enqueue_message(tmp_queue, tmp_buf);
tmp_char = sample_string[i];
if(tmp_char == NULL)
break;
i++;
}
int len;
buffer *out;
for( len = tmp_queue->length; len > 0; len-- )
{
out = dequeue_message(tmp_queue);
if(out->data == NULL)
break;
printf("%s\n", out->data);
free_buffer(out);
}
delete_message_queue(tmp_queue);
/*****************test 2********************************/
message_queue *tmp_queue_;
if((tmp_queue_ = create_message_queue()) == NULL)
{
printf("create queue error!\n");
return -1;
}
int j = 1;
buffer *tmp_buf_;
char *tmp_char_;
tmp_char_ = *sample_string;
while( tmp_char_ != NULL )
{
tmp_buf_ = alloc_buffer_with_length(10);
strcpy(tmp_buf_->data, tmp_char_);
printf("the insert is %s, and %d\n",(char*)tmp_buf_->data,sizeof(*(tmp_buf_->data)));
enqueue_message(tmp_queue_, tmp_buf_);
tmp_char_ = sample_string[j];
if(tmp_char_ == NULL)
break;
j++;
}
delete_message_queue(tmp_queue_);
/*****************end of test********************************/
return 0;
}
