/**
* @returns The data associated with the tail item, or NULL if none.
*/
void *
list_tail(const list_t *list)
{
list_check(list);
return list->tail ? list->tail->data : NULL;
}
/**
* Remove `key' from the list.
* @return whether we found the item in the list and deleted it.
*/
bool
list_remove(list_t *list, const void *key)
{
GList *item;
list_check(list);
item = g_list_find(list->head, deconstify_pointer(key));
if (item) {
if (item == list->head) {
list->head = g_list_next(list->head);
}
if (item == list->tail) {
list->tail = g_list_previous(list->tail);
}
/* @note: Return value is only assigned to "item" because
* g_slist_delete_link is incorrectly tagged to
* cause a GCC compiler warning otherwise.
*/
item = g_list_delete_link(item, item);
list->length--;
list->stamp++;
list_regression(list);
return TRUE;
}
return FALSE;
}
/**
* @returns the length of the list.
*/
uint
list_length(const list_t *list)
{
list_check(list);
return list->length;
}
/**
* @returns the first item of the list, or NULL if none.
*/
void *
list_head(const list_t *list)
{
list_check(list);
return list->head ? list->head->data : NULL;
}
int main(void)
{
struct child c1, c2;
struct list_head list = LIST_HEAD_INIT(list);
plan_tests(1);
list_add(&list, &c1.list);
list_add_tail(list_check(&list, "Bad list!"), &c2.list);
list_del_from(list_check(&list, "Bad list!"),
list_check_node(&c2.list, "Bad node!"));
list_del_from(list_check(&list, "Bad list!"),
list_check_node(&c1.list, "Bad node!"));
ok1(list_empty(list_check(&list, "Bad emptied list")));
return exit_status();
}
/*
Multiplies b[0..k-1] by c[0..k-1], stores the result in a[0..2k-2],
and stores the reduced product in a2[0..2k-2].
(Here, there is no implicit monic leading monomial.)
Requires at least list_mul_mem(k) cells in t.
*/
void
list_mulmod (listz_t a2, listz_t a, listz_t b, listz_t c, unsigned int k,
listz_t t, mpz_t n)
{
int i;
for (i = k; (i & 1) == 0; i >>= 1);
ASSERTD(list_check(b,k,n));
ASSERTD(list_check(c,k,n));
if (i == 1 && Fermat)
F_mul (a, b, c, k, DEFAULT, Fermat, t);
else
LIST_MULT_N (a, b, c, k, t); /* set a[0]...a[2l-2] */
list_mod (a2, a, 2 * k - 1, n);
}
/**
* Apply `func' to all the items in the structure.
*/
void
list_foreach(const list_t *list, GFunc func, void *user_data)
{
list_check(list);
g_assert(func);
g_list_foreach(list->head, func, user_data);
list_regression(list);
}
struct rfc822_msg *rfc822_check(const struct rfc822_msg *msg,
const char *abortstr)
{
assert(msg);
if (!list_check(&msg->headers, abortstr))
return NULL;
if (!tal_check(msg, abortstr))
return NULL;
return (struct rfc822_msg *)msg;
}
void* list_pop_front(list_t* list) {
list_node_t* node = list_check(list->head);
void* data = node->data;
list->head = node->next;
vmm_free(node, sizeof(list_node_t));
if (!list->head)
list->tail = 0;
else
list->head->prev = 0;
return data;
}
void* list_pop_back(list_t* list) {
list_node_t* node = list_check(list->tail);
void* data = node->data;
list->tail = node->prev;
vmm_free(node, sizeof(list_node_t));
if (!list->tail)
list->head = 0;
else
list->tail->next = 0;
return data;
}
/* puts in a[0]..a[K-1] the K low terms of the product
of b[0..K-1] and c[0..K-1].
Assumes K >= 1, and a[0..2K-2] exist.
Needs space for list_mul_mem(K) in t.
*/
static void
list_mul_low (listz_t a, listz_t b, listz_t c, unsigned int K, listz_t t,
mpz_t n)
{
unsigned int p, q;
ASSERT(K > 0);
switch (K)
{
case 1:
mpz_mul (a[0], b[0], c[0]);
return;
case 2:
mpz_mul (a[0], b[0], c[0]);
mpz_mul (a[1], b[0], c[1]);
mpz_addmul (a[1], b[1], c[0]);
return;
case 3:
karatsuba (a, b, c, 2, t);
mpz_addmul (a[2], b[2], c[0]);
mpz_addmul (a[2], b[0], c[2]);
return;
default:
/* MULT is 2 for Karatsuba, 3 for Toom3, 4 for Toom4 */
for (p = 1; MULT * p <= K; p *= MULT); /* p = greatest power of MULT <=K */
p = (K / p) * p;
ASSERTD(list_check(b,p,n) && list_check(c,p,n));
LIST_MULT_N (a, b, c, p, t);
if ((q = K - p))
{
list_mul_low (t, b + p, c, q, t + 2 * q - 1, n);
list_add (a + p, a + p, t, q);
list_mul_low (t, c + p, b, q, t + 2 * q - 1, n);
list_add (a + p, a + p, t, q);
}
}
}
void list_remove(list_t* list, void* data) {
list_node_t* node = list->head;
for (int i = 0; node && node->data != data; i++)
node = node->next;
if (!list_check(node))
return;
if (node->prev)
node->prev->next = node->next;
else
list->head = node->next;
if (node->next)
node->next->prev = node->prev;
else
list->tail = node->prev;
}
/**
* Dispose of all the items remaining in the list, applying the supplied
* free callback on all the items, then freeing the list_t container
* and nullifying its pointer.
*/
void
list_free_all(list_t **list_ptr, list_destroy_cb freecb)
{
g_assert(list_ptr != NULL);
g_assert(freecb != NULL);
if (*list_ptr != NULL) {
list_t *list = *list_ptr;
list_check(list);
G_LIST_FOREACH_WITH_DATA(list->head, list_freecb_wrapper,
cast_func_to_pointer(freecb));
list_free(list_ptr);
}
}
/**
* Prepend `key' to the list.
*/
void
list_prepend(list_t *list, const void *key)
{
list_check(list);
g_assert(1 == list->refcount);
list->head = g_list_prepend(list->head, deconstify_pointer(key));
if (!list->tail) {
list->tail = list->head;
}
list->length++;
list->stamp++;
list_regression(list);
}
/**
* Check whether list contains the `key' whereas equality is determined
* using `func'.
*/
bool
list_contains(list_t *list, const void *key, GEqualFunc func, void **orig_key)
{
GList *item;
list_check(list);
g_assert(func);
for (item = list->head; NULL != item; item = g_list_next(item)) {
if (func(key, item->data)) {
if (orig_key) {
*orig_key = item->data;
}
return TRUE;
}
}
return FALSE;
}
/**
* Insert `key' into the list.
*/
void
list_insert_sorted(list_t *list, const void *key, GCompareFunc func)
{
list_check(list);
g_assert(1 == list->refcount);
g_assert(func);
list->head = g_list_insert_sorted(list->head,
deconstify_pointer(key), func);
if (list->tail) {
list->tail = g_list_last(list->tail);
} else {
list->tail = list->head;
}
list->length++;
list->stamp++;
list_regression(list);
}
/**
* Remove the head of the list.
*
* @return the key at the head of the list, NULL if none.
*/
void *
list_shift(list_t *list)
{
GList *item;
void *key;
bool found;
list_check(list);
item = list->head;
if (NULL == item)
return NULL;
key = item->data;
found = list_remove(list, key);
g_assert(found);
return key;
}
int run_checks()
{
int numerr = 0;
if ( memdebug ) memory_report();
numerr += list_check();
if ( web.representation != SIMPLEX )
{ numerr += facetedge_check(REGCHECK);
if ( web.skel[BODY].count > 0 )
numerr += facet_body_check();
numerr += collapse_check();
numerr += vertex_facet_check();
}
numerr += method_check();
if ( web.symmetry_flag ) numerr += wrap_check();
#ifdef MPI_EVOLVER
numerr += mpi_task_checks();
#endif
check_count = numerr;
return numerr;
} /* end run_checks() */
/**
* Get an iterator on the list, positioned after tail item.
* Get items with list_previous().
*/
list_iter_t *
list_iter_after_tail(list_t *list)
{
list_iter_t *iter;
if (list) {
list_check(list);
WALLOC(iter);
iter->magic = LIST_ITER_MAGIC;
iter->list = list;
iter->next = NULL;
iter->prev = list->tail;
iter->data = NULL;
iter->stamp = list->stamp;
list->refcount++;
} else {
iter = NULL;
}
return iter;
}
int
read_kfile( SNET *sn, char *kfile )
{
int ac;
int linenum = 0;
char **av;
char line[ MAXPATHLEN ];
char path[ MAXPATHLEN ];
ACAV *acav;
FILE *f;
if ( snprintf( path, MAXPATHLEN, "command/%s", kfile ) >= MAXPATHLEN ) {
syslog( LOG_ERR, "read_kfile: command/%s: path too long", kfile );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
return( -1 );
}
if (( acav = acav_alloc( )) == NULL ) {
syslog( LOG_ERR, "acav_alloc: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
return( -1 );
}
if (( f = fopen( path, "r" )) == NULL ) {
syslog( LOG_ERR, "fopen: %s: %m", path );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
return( -1 );
}
while ( fgets( line, MAXPATHLEN, f ) != NULL ) {
linenum++;
ac = acav_parse( acav, line, &av );
if (( ac == 0 ) || ( *av[ 0 ] == '#' )) {
continue;
}
/* Skip minus lines in command files for now. Eventually,
* the server should not give access to command files, special files
* and transcripts that have been ultimately removed with a '-'.
* This is difficult as ktcheck reads command files line by line
* and will request info on a file that might be removed with a
* later '-'.
*/
if ( *av[ 0 ] == '-' ) {
continue;
}
if ( ac != 2 ) {
syslog( LOG_ERR, "%s: line %d: invalid number of arguments",
kfile, linenum );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n",
421 );
goto error;
}
switch( *av[ 0 ] ) {
case 'k':
if ( !list_check( access_list, av[ 1 ] )) {
if ( list_insert( access_list, av[ 1 ] ) != 0 ) {
syslog( LOG_ERR, "list_insert: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
goto error;
}
if ( read_kfile( sn, av[ 1 ] ) != 0 ) {
goto error;
}
}
break;
case 'p':
case 'n':
if ( !list_check( access_list, av[ 1 ] )) {
if ( list_insert( access_list, av[ 1 ] ) != 0 ) {
syslog( LOG_ERR, "list_insert: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
goto error;
}
}
break;
case 's':
case 'x':
break;
default:
syslog( LOG_ERR, "%s: line %d: %c: unknown file type", kfile,
linenum, *av[ 0 ] );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n",
421 );
goto error;
}
if ( ferror( f )) {
syslog( LOG_ERR, "fgets: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n",
421 );
goto error;
}
}
if ( fclose( f ) != 0 ) {
syslog( LOG_ERR, "fclose: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
goto error;
}
if ( acav_free( acav ) != 0 ) {
syslog( LOG_ERR, "acav_free: %m" );
snet_writef( sn,
"%d Service not available, closing transmission channel\r\n", 421 );
return( -1 );
}
return( 0 );
error:
fclose( f );
acav_free( acav );
return( -1 );
}
/*
divides a[0]+a[1]*x+...+a[2K-1]*x^(2K-1)
By b[0]+b[1]*x+...+b[K-1]*x^(K-1)+x^K
i.e. a polynomial of 2K coefficients divided by a monic polynomial
with K+1 coefficients (b[K]=1 is implicit).
Puts the quotient in q[0]+q[1]*x+...+q[K-1]*x^(K-1)
and the remainder in a[0]+a[1]*x+...+a[K-1]*x^(K-1)
Needs space for list_mul_mem(K) coefficients in t.
If top is non-zero, a[0]..a[K-1] are reduced mod n.
*/
void
RecursiveDivision (listz_t q, listz_t a, listz_t b, unsigned int K,
listz_t t, mpz_t n, int top)
{
if (K == 1) /* a0+a1*x = a1*(b0+x) + a0-a1*b0 */
{
mpz_mod (a[1], a[1], n);
mpz_mul (q[0], a[1], b[0]);
mpz_mod (q[0], q[0], n);
mpz_sub (a[0], a[0], q[0]);
if (top)
mpz_mod (a[0], a[0], n);
mpz_set (q[0], a[1]);
}
else
{
unsigned int k, l, i, po2;
k = K / 2;
l = K - k;
for (po2 = K; (po2 && 1) == 0; po2 >>= 1);
po2 = (po2 == 1);
/* first perform a (2l) / l division */
RecursiveDivision (q + k, a + 2 * k, b + k, l, t, n, 0);
/* subtract q[k..k+l-1] * b[0..k-1] */
ASSERTD(list_check(q+l,k,n) && list_check(b,k,n));
if (po2 && Fermat)
F_mul (t, q + l, b, k, DEFAULT, Fermat, t + K); /* sets t[0..2*k-2]*/
else
LIST_MULT_N (t, q + l, b, k, t + K - 1); /* sets t[0..2*k-2] */
list_sub (a + l, a + l, t, 2 * k - 1);
if (k < l) /* don't forget to subtract q[k] * b[0..k-1] */
{
for (i=0; i<k; i++)
{
mpz_mul (t[0], q[k], b[i]); /* TODO: need to reduce t[0]? */
mpz_sub (a[k+i], a[k+i], t[0]);
}
}
/* remainder is in a[0..K+k-1] */
/* then perform a (2k) / k division */
RecursiveDivision (q, a + l, b + l, k, t, n, 0);
/* subtract q[0..k-1] * b[0..l-1] */
ASSERTD(list_check(q,k,n) && list_check(b,k,n));
if (po2 && Fermat)
F_mul (t, q, b, k, DEFAULT, Fermat, t + K);
else
LIST_MULT_N (t, q, b, k, t + K - 1);
list_sub (a, a, t, 2 * k - 1);
if (k < l) /* don't forget to subtract q[0..k-1] * b[k] */
{
for (i=0; i<k; i++)
{
mpz_mul (t[0], q[i], b[k]); /* TODO: need to reduce t[0]? */
mpz_sub (a[k+i], a[k+i], t[0]);
}
}
/* normalizes the remainder wrt n */
if (top)
list_mod (a, a, K, n);
}
}
/* puts in q[0..K-1] the quotient of x^(2K-2) by B
where B = b[0]+b[1]*x+...+b[K-1]*x^(K-1) with b[K-1]=1.
*/
void
PolyInvert (listz_t q, listz_t b, unsigned int K, listz_t t, mpz_t n)
{
if (K == 1)
{
mpz_set_ui (q[0], 1);
return;
}
else
{
int k, l, po2, use_middle_product = 0;
#ifdef KS_MULTIPLY
use_middle_product = 1;
#endif
k = K / 2;
l = K - k;
for (po2 = K; (po2 & 1) == 0; po2 >>= 1);
po2 = (po2 == 1 && Fermat != 0);
/* first determine l most-significant coeffs of Q */
PolyInvert (q + k, b + k, l, t, n); /* Q1 = {q+k, l} */
/* now Q1 * B = x^(2K-2) + O(x^(2K-2-l)) = x^(2K-2) + O(x^(K+k-2)).
We need the coefficients of degree K-1 to K+k-2 of Q1*B */
ASSERTD(list_check(q+k,l,n) && list_check(b,l,n));
if (po2 == 0 && use_middle_product)
{
TMulKS (t, k - 1, q + k, l - 1, b, K - 1, n, 0);
list_neg (t, t, k, n);
}
else if (po2)
{
list_revert (q + k, l);
/* This expects the leading monomials explicitly in q[2k-1] and b[k+l-1] */
F_mul_trans (t, q + k, b, K / 2, K, Fermat, t + k);
list_revert (q + k, l);
list_neg (t, t, k, n);
}
else
{
LIST_MULT_N (t, q + k, b, l, t + 2 * l - 1); /* t[0..2l-1] = Q1 * B0 */
list_neg (t, t + l - 1, k, n);
if (k > 1)
{
list_mul (t + k, q + k, l - 1, 1, b + l, k - 1, 1,
t + k + K - 2); /* Q1 * B1 */
list_sub (t + 1, t + 1, t + k, k - 1);
}
}
list_mod (t, t, k, n); /* high(1-B*Q1) */
ASSERTD(list_check(t,k,n) && list_check(q+l,k,n));
if (po2)
F_mul (t + k, t, q + l, k, DEFAULT, Fermat, t + 3 * k);
else
LIST_MULT_N (t + k, t, q + l, k, t + 3 * k - 1);
list_mod (q, t + 2 * k - 1, k, n);
}
}
/* run the state driven loop until game is broken up or finished */
void client_game_run( void )
{
int ms, frame_delay = config.fps?10:1;
int button_clicked, key_pressed;
SDL_Event event;
int abort = 0, i, j, penalty;
/* frame rate */
int frames = 0;
int frame_time = SDL_GetTicks();
event_clear_sdl_queue();
stk_display_fade( STK_FADE_IN, STK_FADE_DEFAULT_TIME );
stats_received = 0;
stk_timer_reset(); ms = 1;
while ( !abort && !stk_quit_request ) {
/* check wether an event occured */
button_clicked = key_pressed = 0;
if ( SDL_PollEvent( &event ) ) {
if ( client_state == CS_PAUSE && game->game_type == GT_NETWORK )
gui_dispatch_event( &event, ms );
else
if ( event.type == SDL_MOUSEBUTTONDOWN )
button_clicked = event.button.button;
else
if ( event.type == SDL_KEYDOWN ) {
key_pressed = event.key.keysym.sym;
if ( handle_default_key( key_pressed, &abort ) )
key_pressed = 0;
}
else
if (event.type == SDL_ACTIVEEVENT)
{
if (event.active.state == SDL_APPINPUTFOCUS ||
event.active.state == SDL_APPACTIVE )
if (event.active.gain == 0 )
client_set_pause(1);
}
}
else if ( client_state == CS_PAUSE && game->game_type == GT_NETWORK )
gui_dispatch_event( 0, ms );
/* check whether Shift is pressed to switch between own and highest score */
if (game->game_type == GT_LOCAL)
handle_display_switch();
/* let server know we're still alive except
* in CS_PLAY as we send paddle updates there */
if ( game->game_type == GT_NETWORK )
comm_send_heartbeat();
/* handle client */
switch ( client_state ) {
case CS_FINAL_STATS:
if ( key_pressed==SDLK_SPACE ) abort = 1;
break;
case CS_FATAL_ERROR:
/* after game was violently broken up the server
* may still send the stats of the game so far */
if ( button_clicked || key_pressed ) {
SDL_Delay(250); /* give time to release button */
set_state( CS_RECV_STATS );
display_text( font, "Receiving final stats..." );
}
break;
case CS_FINAL_TABLE:
if ( button_clicked || key_pressed ) {
check_highscores();
select_chart( game_set->name, 0 );
/* remove saved game */
slot_delete( 0 );
slot_update_hint( 0, item_resume_0->hint );
/* quit local game */
abort = 1;
}
break;
case CS_SCORE_TABLE:
/* show who's next player and scores in local game */
display_score_table( "Next Player: %s", cur_player->name );
set_state( CS_GET_READY );
break;
case CS_BONUS_LEVEL_SCORE:
/* display total score from this level for player */
display_bonus_level_score();
set_state( CS_GET_READY_FOR_NEXT_LEVEL );
break;
case CS_FINAL_PLAYER_INFO:
if ( button_clicked || key_pressed ) {
SDL_Delay(250); /* give time to release button */
set_state( CS_NEXT_PLAYER );
}
break;
case CS_RECV_LEVEL:
comm_recv();
if ( cur_player->next_level_received ) {
cur_player->next_level_received = 0;
cur_player->paddle_id = cur_player->next_paddle_id;
init_next_round();
}
break;
case CS_RECV_STATS:
comm_recv();
if ( stats_received ) {
set_state( CS_FINAL_STATS );
display_final_stats();
}
break;
case CS_ROUND_RESULT:
if ( button_clicked || key_pressed ) {
SDL_Delay(250); /* give time to release button */
if ( game_over ) {
set_state( CS_RECV_STATS );
display_text( font, "Receiving final stats..." );
} else {
set_state( CS_RECV_LEVEL );
display_text( font, "Receiving level data..." );
}
}
break;
case CS_GET_READY:
if ( button_clicked || key_pressed ) {
SDL_Delay(250); /* give time to release button */
comm_send_short( MSG_READY );
set_state( CS_PLAY );
}
break;
case CS_GET_READY_FOR_NEXT_LEVEL:
if ( button_clicked || key_pressed ) {
SDL_Delay(250); /* give time to release button */
set_state( CS_NEXT_LEVEL );
}
break;
case CS_PAUSE:
if ( game->game_type == GT_LOCAL ) break;
/* check wether pause chatroom has been closed
* either by client or remote */
comm_recv();
break;
case CS_PLAY:
/* hide objects */
begin_frame();
/* apply events to local paddle */
paddle_handle_events( l_paddle, ms );
/* update local objects and communicate if
* comm_delay ms have passed */
update_game( ms );
/* show objects */
end_frame();
/* handle local level over */
if ( game->level_over ) {
if ( game->game_type == GT_LOCAL ) {
if ( game_set == 0 ) {
abort = 1; /* was a test level */
grab_input(0);
break;
}
if ( game->winner == PADDLE_BOTTOM )
{
if (local_game->isBonusLevel)
set_state( CS_BONUS_LEVEL_SCORE );
else
set_state( CS_NEXT_LEVEL );
}
else
set_state( CS_LOOSE_LIFE );
} else {
finalize_round();
}
}
break;
case CS_NEXT_LEVEL:
/* apply paddle stats to player */
game_set_current( local_game );
game_update_stats( PADDLE_BOTTOM, &cur_player->stats );
game_set_current( game );
/* init next level for player in local game */
cur_player->level_id++;
if ( cur_player->level_id >= game_set->count ) {
/* deactivate player */
cur_player->lives = 0;
display_text( font,
"You've cleared all levels...#Congratulations!!!" );
set_state( CS_FINAL_PLAYER_INFO );
break;
}
/* get snapshot for next init */
cur_player->snapshot = *game_set->levels[cur_player->level_id];
/* cycle players */
set_state( CS_NEXT_PLAYER );
break;
case CS_RESTART_LEVEL:
/* apply paddle stats to player */
game_set_current( local_game );
game_update_stats( PADDLE_BOTTOM, &cur_player->stats );
game_set_current( game );
/* reset level for next turn */
cur_player->snapshot = *game_set->levels[cur_player->level_id];
/* decrease lives (is checked that this wasn't the last one) */
cur_player->lives--;
/* cycle players */
set_state( CS_NEXT_PLAYER );
break;
case CS_LOOSE_LIFE:
/* apply paddle stats to player */
game_set_current( local_game );
game_update_stats( PADDLE_BOTTOM, &cur_player->stats );
game_set_current( game );
/* remember level for next turn */
game_get_level_snapshot( &cur_player->snapshot );
/* decrease lives */
cur_player->lives--;
if ( cur_player->lives == 0 ) {
display_text( font,
"You've lost all lives...#Do you want to buy a continue#for 100%% of your score? y/n" );
set_state( CS_CONFIRM_CONTINUE );
//set_state( CS_FINAL_PLAYER_INFO );
break;
}
set_state( CS_NEXT_PLAYER );
break;
case CS_NEXT_PLAYER:
/* game over? */
if ( players_count() == 0 ) {
display_score_table( "Game Over!" );
set_state( CS_FINAL_TABLE );
break;
}
/* speak and fade */
play_speech();
fade_anims();
/* finalize current game context */
finalize_level();
/* set next player */
cur_player = players_get_next();
init_level( cur_player, PADDLE_BOTTOM );
if ( player_count > 1 )
set_state( CS_SCORE_TABLE );
else {
set_state( CS_PLAY ); /* one player starts immediately */
stk_display_update( STK_UPDATE_ALL );
}
break;
case CS_CONFIRM_CONTINUE:
case CS_CONFIRM_QUIT:
case CS_CONFIRM_WARP:
case CS_CONFIRM_RESTART:
if ( key_pressed == 0 ) break;
if ( key_pressed==SDLK_n||key_pressed==SDLK_ESCAPE ) {
/* if denying continue... DIE!!! */
if ( client_state == CS_CONFIRM_CONTINUE )
{
SDL_Delay(250); /* give time to release button */
set_state( CS_NEXT_PLAYER );
//set_state( CS_FINAL_PLAYER_INFO );
}
else
set_state( CS_PLAY );
break;
}
if ( key_pressed != SDLK_y && key_pressed != SDLK_z ) break;
/* handle confirmed action */
SDL_Delay(250); /* give time to release button */
switch( client_state ) {
case CS_CONFIRM_CONTINUE:
/* clear score and give full lives again */
cur_player->lives = game->diff->lives;
cur_player->stats.total_score = 0;
set_state( CS_NEXT_PLAYER );
break;
case CS_CONFIRM_QUIT:
comm_send_short( MSG_QUIT_GAME );
if ( game->game_type == GT_LOCAL ) {
/* apply paddle stats to player */
game_set_current( local_game );
game_update_stats( PADDLE_BOTTOM, &cur_player->stats );
game_set_current( game );
/* no higscore check anymore as game is supposed to
* be resumed until normal game over */
/* testing levels don't got for
* high scores ***
if ( game_set ) {
check_highscores();
select_chart( game_set->name, 0 );
}*/
/* save local game */
if ( game_set != 0 /*not testing a level*/ )
save_local_game( 0 );
abort = 1;
}
else {
/* await game stats */
set_state( CS_RECV_STATS );
display_text( font, "Receiving final stats..." );
}
break;
case CS_CONFIRM_WARP:
game->winner = -1; /* no speech */
local_game->winner = -1; /* not counted as win */
/* substract doubled score of remaining bricks */
penalty = 0;
for ( i = 0; i < MAP_WIDTH; i++ )
for ( j = 0; j < MAP_HEIGHT; j++ )
if ( local_game->bricks[i][j].dur != -1 )
penalty += local_game->bricks[i][j].score;
printf( "warp penalty: -%d\n", penalty );
local_game->paddles[0]->score -= penalty;
set_state( CS_NEXT_LEVEL );
break;
case CS_CONFIRM_RESTART:
game->winner = -1; /* no speech */
local_game->winner = -1; /* not counted as win */
local_game->level_over = 1;
set_state( CS_RESTART_LEVEL );
break;
}
break;
}
/* update anything that was changed */
stk_display_update( STK_UPDATE_RECTS );
/* get time since last call and delay if below frame_delay */
ms = stk_timer_get_time();
if ( ms < frame_delay ) {
SDL_Delay( frame_delay - ms );
ms += stk_timer_get_time();
}
frames++;
}
finalize_level();
client_state = CLIENT_NONE;
stk_display_fade( STK_FADE_OUT, STK_FADE_DEFAULT_TIME );
if ( stk_quit_request )
comm_send_short( MSG_DISCONNECT );
else
comm_send_short( MSG_UNHIDE );
/* frame rate */
frame_time = SDL_GetTicks() - frame_time;
printf( "Time: %.2f, Frames: %i -> FPS: %.2f\n",
(double)frame_time / 1000, frames, 1000.0*frames/frame_time );
event_clear_sdl_queue();
/* update the selected user and the user list in network as
* we received ADD/REMOVE_USER messages */
gui_list_update( list_users, client_users->count );
/* re-select current entry */
if ( client_user ) {
i = list_check( client_users, client_user );
if ( i != -1 )
gui_list_select( list_users, 0, i, 1 );
}
}
void list_check(Pname nn, Ptype t, Pexpr il)
/*
see if the list "lll" can be assigned to something of type "t"
"nn" is the name of the variable for which the assignment is taking place.
"il" is the last list element returned by next_elem()
*/
{
Pexpr e;
bit lst = 0;
int i;
Pclass cl;
//error('d',"list_check%n: %t (%d)",nn,t,il);
switch ( (int)il ) {
case 0: break;
case 1: lst = 1; break;
default: list_put_back(il);
}
zzz:
switch (t->base) {
case TYPE:
t = Pbase(t)->b_name->tp;
goto zzz;
case VEC:
{ Pvec v = (Pvec)t;
Ptype vt = v->typ;
if (v->size) { /* get at most v->size initializers */
if (v->typ->base == CHAR) {
e = next_elem();
if (e->base == STRING) { // v[size] = "..."
int isz = Pvec(e->tp)->size;
if (v->size < isz) error("Ir too long (%d characters) for%n[%d]",isz,nn,v->size);
break;
}
else
list_put_back(e);
}
for (i=0; i<v->size; i++) { // check next list element type
ee:
e = next_elem();
if (e == 0) goto xsw; // too few initializers are ok
vtz:
//error('d',"vtz: %d",vt->base);
switch (vt->base) {
case TYPE:
vt = Pbase(vt)->b_name->tp;
goto vtz;
case VEC:
case COBJ:
list_check(nn,vt,e);
break;
default:
if (e == (Pexpr)1) {
error("unXIrL");
goto ee;
}
if (vt->check(e->tp,ASSIGN))
error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
}
}
if ( lst && (e=next_elem()) ) error("end ofIrLX after vector");
xsw:;
}
else { /* determine v->size */
i = 0;
xx:
while ( e=next_elem() ) { // get another initializer
i++;
vtzz:
//error('d',"vtzz: %d",vt->base);
switch (vt->base) {
case TYPE:
vt = Pbase(vt)->b_name->tp;
goto vtzz;
case VEC:
case COBJ:
list_check(nn,vt,e);
break;
default:
if (e == (Pexpr)1) {
error("unXIrL");
goto xx;
}
if (vt->check(e->tp,ASSIGN))
error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
}
}
v->size = i;
}
break;
}
case CLASS:
cl = (Pclass)t;
goto ccc;
case COBJ: /* initialize members */
cl = Pclass(Pbase(t)->b_name->tp);
ccc:
{ Ptable tbl = cl->memtbl;
Pname m;
if (cl->clbase) list_check(nn,cl->clbase->tp,0);
for (m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i)) {
Ptype mt = m->tp;
switch (mt->base) {
case FCT:
case OVERLOAD:
case CLASS:
case ENUM:
continue;
}
if (m->n_stclass == STATIC) continue;
/* check assignment to next member */
dd:
e = next_elem();
if (e == 0) return; //break;
mtz:
//error('d',"mtz%n: %d",m,mt->base);
switch (mt->base) {
case TYPE:
mt = Pbase(mt)->b_name->tp;
goto mtz;
case CLASS:
case ENUM:
break;
case VEC:
case COBJ:
list_check(nn,m->tp,e);
break;
default:
if (e == (Pexpr)1) {
error("unXIrL");
goto dd;
}
if (mt->check(e->tp,ASSIGN))
error("badIrT for%n:%t (%tX)",m,e->tp,m->tp);
}
}
if (lst && (e=next_elem()) ) error("end ofIrLX afterCO");
break;
}
default:
e = next_elem();
if (e == 0) {
error("noIr forO");
break;
}
if (e == (Pexpr)1) {
error("unXIrL");
break;
}
if (t->check(e->tp,ASSIGN)) error("badIrT for%n:%t (%tX)",nn,e->tp,t);
if (lst && (e=next_elem()) ) error("end ofIrLX afterO");
break;
}
}
int
f_retr( SNET *sn, int ac, char **av )
{
ssize_t readlen;
struct stat st;
struct timeval tv;
char buf[8192];
char path[ MAXPATHLEN ];
char *d_path, *d_tran;
int fd;
switch ( keyword( ac, av )) {
case K_COMMAND:
if ( ac == 2 ) {
if ( snprintf( path, MAXPATHLEN, "command/%s", command_file )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_retr: command/%s: path too long",
command_file );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
} else {
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_retr: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_path )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s",
d_path );
snet_writef( sn, "%d No access for %s\r\n", 540, d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "command/%s", d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_retr: command path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
}
break;
case K_TRANSCRIPT:
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_retr: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s\r\n", 540, d_tran );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "transcript/%s", d_tran )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_retr: transcript path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_SPECIAL:
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_retr: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "%s/%s", special_dir, d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_retr: special path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_FILE:
if (( d_path = decode( av[ 3 ] )) == NULL ) {
syslog( LOG_ERR, "f_retr: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if (( d_path = strdup( d_path )) == NULL ) {
syslog( LOG_ERR, "f_retr: strdup: %s: %m", d_path );
return( -1 );
}
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_retr: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s:%s\r\n", 540, d_tran,
d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "file/%s/%s", d_tran, d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_retr: file path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
free( d_path );
break;
default:
snet_writef( sn, "%d RETR Syntax error\r\n", 540 );
return( 1 );
}
if (( fd = open( path, O_RDONLY, 0 )) < 0 ) {
syslog( LOG_ERR, "open: %s: %m", path );
snet_writef( sn, "%d Unable to access %s.\r\n", 543, path );
return( 1 );
}
/* dump file info */
if ( fstat( fd, &st ) < 0 ) {
syslog( LOG_ERR, "f_retr: fstat: %m" );
snet_writef( sn, "%d Access Error: %s\r\n", 543, path );
if ( close( fd ) < 0 ) {
syslog( LOG_ERR, "close: %m" );
return( -1 );
}
return( 1 );
}
/*
* Here's a problem. Do we need to add long long support to
* snet_writef?
*/
snet_writef( sn, "240 Retrieving file\r\n%" PRIofft "d\r\n", st.st_size );
/* dump file */
while (( readlen = read( fd, buf, sizeof( buf ))) > 0 ) {
tv.tv_sec = 60 ;
tv.tv_usec = 0;
if ( snet_write( sn, buf, readlen, &tv ) != readlen ) {
syslog( LOG_ERR, "snet_write: %m" );
return( -1 );
}
}
if ( readlen < 0 ) {
syslog( LOG_ERR, "read: %m" );
return( -1 );
}
snet_writef( sn, ".\r\n" );
if ( close( fd ) < 0 ) {
syslog( LOG_ERR, "close: %m" );
return( -1 );
}
syslog( LOG_DEBUG, "f_retr: 'file' %s retrieved", path );
return( 0 );
}
int main(void)
{
struct dt_node *root, *c1, *c2, *gc1, *gc2, *gc3, *ggc1, *i;
const struct dt_property *p;
struct dt_property *p2;
unsigned int n;
root = dt_new_root("root");
assert(!list_top(&root->properties, struct dt_property, list));
c1 = dt_new(root, "c1");
assert(!list_top(&c1->properties, struct dt_property, list));
c2 = dt_new(root, "c2");
assert(!list_top(&c2->properties, struct dt_property, list));
gc1 = dt_new(c1, "gc1");
assert(!list_top(&gc1->properties, struct dt_property, list));
gc2 = dt_new(c1, "gc2");
assert(!list_top(&gc2->properties, struct dt_property, list));
gc3 = dt_new(c1, "gc3");
assert(!list_top(&gc3->properties, struct dt_property, list));
ggc1 = dt_new(gc1, "ggc1");
assert(!list_top(&ggc1->properties, struct dt_property, list));
for (n = 0, i = dt_first(root); i; i = dt_next(root, i), n++) {
assert(!list_top(&i->properties, struct dt_property, list));
dt_add_property_cells(i, "visited", 1);
}
assert(n == 6);
for (n = 0, i = dt_first(root); i; i = dt_next(root, i), n++) {
p = list_top(&i->properties, struct dt_property, list);
assert(strcmp(p->name, "visited") == 0);
assert(p->len == sizeof(u32));
assert(fdt32_to_cpu(*(u32 *)p->prop) == 1);
}
assert(n == 6);
dt_add_property_cells(c1, "some-property", 1, 2, 3);
p = dt_find_property(c1, "some-property");
assert(p);
assert(strcmp(p->name, "some-property") == 0);
assert(p->len == sizeof(u32) * 3);
assert(fdt32_to_cpu(*(u32 *)p->prop) == 1);
assert(fdt32_to_cpu(*((u32 *)p->prop + 1)) == 2);
assert(fdt32_to_cpu(*((u32 *)p->prop + 2)) == 3);
/* Test freeing a single node */
assert(!list_empty(&gc1->children));
dt_free(ggc1);
assert(list_empty(&gc1->children));
/* Test rodata logic. */
assert(!is_rodata("hello"));
assert(is_rodata(__rodata_start));
strcpy(__rodata_start, "name");
ggc1 = dt_new(root, __rodata_start);
assert(ggc1->name == __rodata_start);
/* Test string node. */
dt_add_property_string(ggc1, "somestring", "someval");
assert(dt_has_node_property(ggc1, "somestring", "someval"));
assert(!dt_has_node_property(ggc1, "somestrin", "someval"));
assert(!dt_has_node_property(ggc1, "somestring", "someva"));
assert(!dt_has_node_property(ggc1, "somestring", "somevale"));
/* Test resizing property. */
p = p2 = __dt_find_property(c1, "some-property");
assert(p);
n = p2->len;
while (p2 == p) {
n *= 2;
dt_resize_property(&p2, n);
}
assert(dt_find_property(c1, "some-property") == p2);
list_check(&c1->properties, "properties after resizing");
dt_del_property(c1, p2);
list_check(&c1->properties, "properties after delete");
/* No leaks for valgrind! */
dt_free(root);
return 0;
}
int
f_stat( SNET *sn, int ac, char *av[] )
{
char path[ MAXPATHLEN ];
char cksum_b64[ SZ_BASE64_E( EVP_MAX_MD_SIZE ) ];
struct stat st;
int key;
char *enc_file, *d_tran, *d_path;
switch ( key = keyword( ac, av )) {
case K_COMMAND:
if ( ac == 2 ) {
if ( snprintf( path, MAXPATHLEN, "command/%s", command_file )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command/%s: path too long",
command_file );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
} else {
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_path )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s",
d_path );
snet_writef( sn, "%d No access for %s\r\n", 540, d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "command/%s", d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
}
break;
case K_TRANSCRIPT:
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s\r\n", 540, d_tran );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "transcript/%s", d_tran )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: transcript path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_SPECIAL:
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "%s/%s", special_dir, d_path)
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: special path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
default:
snet_writef( sn, "%d STAT Syntax error\r\n", 530 );
return( 1 );
}
syslog( LOG_DEBUG, "f_stat: returning infomation for %s", path );
if ( stat( path, &st ) < 0 ) {
syslog( LOG_ERR, "f_stat: stat: %m" );
snet_writef( sn, "%d Access Error: %s\r\n", 531, path );
return( 1 );
}
/* XXX cksums here, totally the wrong place to do this! */
OpenSSL_add_all_digests();
md = EVP_get_digestbyname( "sha1" );
if ( !md ) {
/* XXX */
fprintf( stderr, "%s: unsupported checksum\n", "sha1" );
exit( 1 );
}
if ( do_cksum( path, cksum_b64 ) < 0 ) {
syslog( LOG_ERR, "do_cksum: %s: %m", path );
snet_writef( sn, "%d Checksum Error: %s: %m\r\n", 500, path );
return( 1 );
}
snet_writef( sn, "%d Returning STAT information\r\n", 230 );
switch ( key ) {
case K_COMMAND:
if ( ac == 2 ) {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", "command", DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
} else {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ], DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
}
return( 0 );
case K_TRANSCRIPT:
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
case K_SPECIAL:
/* status on a special file comes from 1 of three cases:
* 1. A transcript in the special file directory
* 2. A transcript in the Transcript dir with .T appended
* 3. No transcript is found, and constants are returned
*/
/* look for transcript containing the information */
if ( ( strlen( path ) + 2 ) > MAXPATHLEN ) {
syslog( LOG_WARNING,
"f_stat: transcript path longer than MAXPATHLEN" );
/* return constants */
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
}
/* if allowable, check for transcript in the special file directory */
strcat( path, ".T" );
/* store value of av[ 2 ], because argcargv will be called
* from special_t(), and that will blow away the current values
* for av[ 2 ]
*
* Could just use new argvargc API... XXX Notice how we never free
* env_file...
*/
if (( enc_file = strdup( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: strdup: %s %m", av[ 2 ] );
return( -1 );
}
if (( av = special_t( path, enc_file )) == NULL ) {
if (( av = special_t( "transcript/special.T", enc_file ))
== NULL ) {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", enc_file,
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
}
}
snet_writef( sn, "%s %s %s %s %s %d %" PRIofft "d %s\r\n",
av[ 0 ], enc_file,
av[ 2 ], av[ 3 ], av[ 4 ],
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
default:
return( 1 );
}
}
void* list_back(list_t* list) {
return list_check(list->tail)->data;
}
int
f_stat( SNET *sn, int ac, char *av[] )
{
char path[ MAXPATHLEN ];
char cksum_b64[ SZ_BASE64_E( EVP_MAX_MD_SIZE ) ];
struct stat st;
int key;
char *enc_file, *d_tran, *d_path;
switch ( key = keyword( ac, av )) {
case K_COMMAND:
if ( ac == 2 ) {
if ( snprintf( path, MAXPATHLEN, "command/%s", command_file )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command/%s: path too long",
command_file );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
} else {
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_path )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s",
d_path );
snet_writef( sn, "%d No access for %s\r\n", 540, d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "command/%s", d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
}
break;
case K_TRANSCRIPT:
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s\r\n", 540, d_tran );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "transcript/%s", d_tran )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: transcript path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_SPECIAL:
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "%s/%s", special_dir, d_path)
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: special path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
default:
snet_writef( sn, "%d STAT Syntax error\r\n", 530 );
return( 1 );
}
syslog( LOG_DEBUG, "f_stat: returning infomation for %s", path );
if ( stat( path, &st ) < 0 ) {
syslog( LOG_ERR, "f_stat: stat: %m" );
snet_writef( sn, "%d Access Error: %s\r\n", 531, path );
return( 1 );
}
/* XXX cksums here, totally the wrong place to do this! */
OpenSSL_add_all_digests();
md = EVP_get_digestbyname( "sha1" );
if ( !md ) {
/* XXX */
fprintf( stderr, "%s: unsupported checksum\n", "sha1" );
exit( 1 );
}
if ( do_cksum( path, cksum_b64 ) < 0 ) {
syslog( LOG_ERR, "do_cksum: %s: %m", path );
snet_writef( sn, "%d Checksum Error: %s: %m\r\n", 500, path );
return( 1 );
}
snet_writef( sn, "%d Returning STAT information\r\n", 230 );
switch ( key ) {
case K_COMMAND:
if ( ac == 2 ) {
snet_writef( sn, RADMIND_STAT_FMT,
"f", "command", DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
} else {
snet_writef( sn, RADMIND_STAT_FMT,
"f", av[ 2 ], DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
}
return( 0 );
case K_TRANSCRIPT:
snet_writef( sn, RADMIND_STAT_FMT,
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
case K_SPECIAL:
/*
* store value of av[ 2 ], because argcargv will be called
* from special_t(), and that will blow away the current values
* for av[ 2 ].
*/
if (( enc_file = strdup( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: strdup: %s %m", av[ 2 ] );
return( -1 );
}
if (( av = special_t( path, enc_file )) == NULL ) {
/* no special transcript match found, return defaults. */
snet_writef( sn, RADMIND_STAT_FMT,
"f", enc_file,
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
}
snet_writef( sn, RADMIND_STAT_FMT,
av[ 0 ], enc_file,
av[ 2 ], av[ 3 ], av[ 4 ],
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
default:
return( 1 );
}
}
void* list_front(list_t* list) {
return list_check(list->head)->data;
}
