Complete.Org: Mailing Lists: Archives: freeciv-dev: September 2004:
[Freeciv-Dev] (PR#10106) civserver crashed on auth error, seehttp://pubs
Home

[Freeciv-Dev] (PR#10106) civserver crashed on auth error, seehttp://pubs

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: per@xxxxxxxxxxx
Subject: [Freeciv-Dev] (PR#10106) civserver crashed on auth error, seehttp://pubserver.freeciv.org/games/332737
From: "James Canete" <use_less@xxxxxxxxxxx>
Date: Wed, 15 Sep 2004 15:01:40 -0700
Reply-to: rt@xxxxxxxxxxx

<URL: http://rt.freeciv.org/Ticket/Display.html?id=10106 >

I'm getting this too, here's my drmingw log.

Client is gui-win32 running a modified connectdlg which I'm trying to
test.  Server is CVS with a minor tweak to the file locks in db
(ignoring them :) and running with -a.

-James Canete
civserver.exe caused an Access Violation at location 004d2849 in module 
civserver.exe Reading from location 00000000.

Registers:
eax=00000000 ebx=00000000 ecx=00002736 edx=0051e410 esi=0051e410 edi=00000000
eip=004d2849 esp=0022fb30 ebp=0022fb48 iopl=0         nv up ei pl nz na po nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000206

Call stack:
004D2849  civserver.exe:004D2849  conn_clear_packet_cache  connection.c:638
void conn_clear_packet_cache(
        struct connection * pc = &{
                int id = 1,
                int sock = 1764,
                _Bool used = (bool),
                _Bool established = (bool),
                struct player * player = 0x00000000,
                _Bool observer = (bool),
                struct socket_packet_buffer * buffer = 0x00000000,
                struct socket_packet_buffer * send_buffer = 0x00000000,
                time_t last_write = 1095285510,
                double ping_time = -1.000000,
                struct conn_list self = {
                        struct genlist list = {
                                int nelements = 1,
                                struct genlist_link * head_link = 0x003d5f48,
                                struct genlist_link * tail_link = 0x003d5f48
                        }
                },
                charuint32[] username = (array),
                charuint32[] addr = (array),
                charuint32[] capability = (array),
                enum cmdlevel_id access_level = ALLOW_NONE,
                _Bool delayed_disconnect = (bool),
                void ()(void) * notify_of_writable_data = 0x00000000,
                struct { int last_request_id_used; int 
last_processed_request_id_seen; int request_id_of_currently_handled_packet; } 
client = {
                        int last_request_id_used = 0,
                        int last_processed_request_id_seen = 0,
                        int request_id_of_currently_handled_packet = 0
                },
                struct { int currently_processed_request_id; int 
last_request_id_seen; struct timer_list * ping_timers; int 
authentication_tries; time_t authentication_stop; enum auth_status status; 
charuint32[] password; } server = {
                        int currently_processed_request_id = 0,
                        int last_request_id_seen = 1,
                        struct timer_list * ping_timers = 0x003d6f58,
                        int authentication_tries = 0,
                        time_t authentication_stop = 0,
                        enum auth_status status = AS_NOT_ESTABLISHED,
                        charuint32[] password = (array)
                },
                void ()(void) * incoming_packet_notify = 0x00000000,
                void ()(void) * outgoing_packet_notify = 0x00000000,
                struct { struct hash_table * * sent; struct hash_table * * 
received; int * variant; } phs = {
                        struct hash_table * * sent = 0x00000000,
                        struct hash_table * * received = 0x00000000,
                        int * variant = 0x00000000
                },
                struct { int frozen_level; struct byte_vector queue; } 
compression = {
                        int frozen_level = 1,
                        struct byte_vector queue = {
                                unsigned char * p = 0x00000000,
                                size_t size = 0,
                                size_t size_alloc = 0
                        }
                },
                struct { int bytes_send; } statistics = {
                        int bytes_send = 3
                }
        }
)
        ...
        
          for (i = 0; i < PACKET_LAST; i++) {
>           if (pc->phs.sent[i] != NULL) {
              struct hash_table *hash = pc->phs.sent[i];
              while (hash_num_entries(hash) > 0) {
        ...

004D26C5  civserver.exe:004D26C5  free_packet_hashes  connection.c:573
static void free_packet_hashes(
        struct connection * pc = &{
                int id = 1,
                int sock = 1764,
                _Bool used = (bool),
                _Bool established = (bool),
                struct player * player = 0x00000000,
                _Bool observer = (bool),
                struct socket_packet_buffer * buffer = 0x00000000,
                struct socket_packet_buffer * send_buffer = 0x00000000,
                time_t last_write = 1095285510,
                double ping_time = -1.000000,
                struct conn_list self = {
                        struct genlist list = {
                                int nelements = 1,
                                struct genlist_link * head_link = 0x003d5f48,
                                struct genlist_link * tail_link = 0x003d5f48
                        }
                },
                charuint32[] username = (array),
                charuint32[] addr = (array),
                charuint32[] capability = (array),
                enum cmdlevel_id access_level = ALLOW_NONE,
                _Bool delayed_disconnect = (bool),
                void ()(void) * notify_of_writable_data = 0x00000000,
                struct { int last_request_id_used; int 
last_processed_request_id_seen; int request_id_of_currently_handled_packet; } 
client = {
                        int last_request_id_used = 0,
                        int last_processed_request_id_seen = 0,
                        int request_id_of_currently_handled_packet = 0
                },
                struct { int currently_processed_request_id; int 
last_request_id_seen; struct timer_list * ping_timers; int 
authentication_tries; time_t authentication_stop; enum auth_status status; 
charuint32[] password; } server = {
                        int currently_processed_request_id = 0,
                        int last_request_id_seen = 1,
                        struct timer_list * ping_timers = 0x003d6f58,
                        int authentication_tries = 0,
                        time_t authentication_stop = 0,
                        enum auth_status status = AS_NOT_ESTABLISHED,
                        charuint32[] password = (array)
                },
                void ()(void) * incoming_packet_notify = 0x00000000,
                void ()(void) * outgoing_packet_notify = 0x00000000,
                struct { struct hash_table * * sent; struct hash_table * * 
received; int * variant; } phs = {
                        struct hash_table * * sent = 0x00000000,
                        struct hash_table * * received = 0x00000000,
                        int * variant = 0x00000000
                },
                struct { int frozen_level; struct byte_vector queue; } 
compression = {
                        int frozen_level = 1,
                        struct byte_vector queue = {
                                unsigned char * p = 0x00000000,
                                size_t size = 0,
                                size_t size_alloc = 0
                        }
                },
                struct { int bytes_send; } statistics = {
                        int bytes_send = 3
                }
        }
)
        ...
          conn_clear_packet_cache(pc);
        
>         for (i = 0; i < PACKET_LAST; i++) {
            if (pc->phs.sent[i] != NULL) {
              hash_free(pc->phs.sent[i]);
        ...

004364E0  civserver.exe:004364E0  sniff_packets  sernet.c:625
int sniff_packets(
        
)
        ...
        connection_do_unbuffer(pconn);
        if (!command_ok) {
>         close_connection(pconn);
        }
        #if PROCESSING_TIME_STATISTICS
        ...

004095F5  civserver.exe:004095F5  srv_loop  srv_main.c:1661
static void srv_loop(
        
)
        ...
          freelog(LOG_NORMAL, _("Now accepting new client connections."));
          while(server_state == PRE_GAME_STATE) {
>           sniff_packets(); /* Accepting commands. */
          }
        
        ...

00408EAD  civserver.exe:00408EAD  srv_main  srv_main.c:1622
void srv_main(
        
)
        ...
            srv_loop();
        
>           send_game_state(&game.game_connections, CLIENT_GAME_OVER_STATE);
            report_final_scores();
            show_map_to_all();
        ...

00401C76  civserver.exe:00401C76  main  civserver.c:170
int main(
        int argc = 2,
        char * * argv = &0x003d258d
)
        ...
        
          /* have arguments, call the main server loop... */
>         srv_main();
        
          /* Technically, we won't ever get here. We exit via server_quit. */
        ...

0040116A  civserver.exe:0040116A
00401018  civserver.exe:00401018
7C816D4F  kernel32.dll:7C816D4F  RegisterWaitForInputIdle

[Prev in Thread] Current Thread [Next in Thread]