Esempio n. 1
0
void *reciever(void *params)
{
  struct hb_entry* temp;
  char *message;
  while(1){
      message = (char *) recvudp(hb_table[host_no].IP,hb_table[host_no].port);
      clear_temp_entry_table(entry);
      temp = extract_message(message);
      update_table(temp); 
  }
}
Esempio n. 2
0
int main( int argc, char * argv[] )
{
    socketdesc sd;         /* socket descriptor index */
    long n;                /* number of bytes received */
    char sendline[MSGSIZE];   /* send buffer */
    char recvline[MSGSIZE+1]; /* recieve buffer */

    /* need an ip address.. localhost or 127.0.0.1 would work for
       our test case */
    if (argc != 2 )
    {
        fprintf( stderr, "echo <ip address>\n" );
        exit(1);
    }

    initudp();
    sd = openudp( FALSE, argv[1], 2007 );

    if ( sd < 0 )
    {
        fprintf( stderr, "error occured while connecting\n" );
        exit(1);
    }

    while ( fgets( sendline, MSGSIZE, stdin ) != NULL )
    {
        sendudp( sd, sendline, strlen(sendline), argv[1] );
      
        n = recvudp( sd, recvline, MSGSIZE, NULL );
        recvline[n] = '\0';
        fputs(recvline, stdout);
    }

    closeudp( sd );

    return 0;
}
Esempio n. 3
0
int32 do_sockets(fd_set* rfd, int32 next)
{
    struct timeval timeout;
    int32 ret;
    memcpy(rfd, &readfds, sizeof(*rfd));

    timeout.tv_sec = next / 1000;
    timeout.tv_usec = next % 1000 * 1000;

    ret = sSelect(fd_max, rfd, nullptr, nullptr, &timeout);

    if (ret == SOCKET_ERROR)
    {
        if (sErrno != S_EINTR)
        {
            ShowFatalError("do_sockets: select() failed, error code %d!\n", sErrno);
            do_final(EXIT_FAILURE);
        }
        return 0; // interrupted by a signal, just loop and try again
    }

    last_tick = time(nullptr);

    if (sFD_ISSET(map_fd, rfd))
    {
        struct sockaddr_in from;
        socklen_t fromlen = sizeof(from);

        int32 ret = recvudp(map_fd, g_PBuff, map_config.buffer_size, 0, (struct sockaddr*)&from, &fromlen);
        if (ret != -1)
        {
            // find player char
#   ifdef WIN32
            uint32 ip = ntohl(from.sin_addr.S_un.S_addr);
#   else
            uint32 ip = ntohl(from.sin_addr.s_addr);
#   endif

            uint64 port = ntohs(from.sin_port);
            uint64 ipp = ip;
            ipp |= port << 32;
            map_session_data_t* map_session_data = mapsession_getbyipp(ipp);

            if (map_session_data == nullptr)
            {
                map_session_data = mapsession_createsession(ip, ntohs(from.sin_port));
                if (map_session_data == nullptr)
                {
					map_session_list.erase(ipp);
                    return -1;
                }
            }

            map_session_data->last_update = time(nullptr);
            size_t size = ret;

            if (recv_parse(g_PBuff, &size, &from, map_session_data) != -1)
            {
                // если предыдущий пакет был потерян, то мы не собираем новый,
                // а отправляем предыдущий пакет повторно
                if (!parse(g_PBuff, &size, &from, map_session_data))
                {
                    send_parse(g_PBuff, &size, &from, map_session_data);
                }

                ret = sendudp(map_fd, g_PBuff, size, 0, (const struct sockaddr*)&from, fromlen);

                int8* data = g_PBuff;
                g_PBuff = map_session_data->server_packet_data;

                map_session_data->server_packet_data = data;
                map_session_data->server_packet_size = size;
            }
            if (map_session_data->shuttingDown > 0)
            {
                map_close_session(gettick(), map_session_data);
            }
        }
    }
    return 0;
}