UDP Server (Broadcast)

SO_BROADCAST skal sættes på både klient og server. Hvis dit netværk har adressen 192.168.0.0 og netmasken 255.255.255.0 så er din broadcast adresse (den du skal sende til når du broadcaster) 192.168.0.255.

Serveren skal bindes til INADDR_ANY...IKKE til broadcast adressen.

Følgende illustrerer det:

 [#include <sys/types.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <string.h>
 
 #define PORT 6677
 
 int client(int s, struct sockaddr_in * addr) {
     char msg[] = "Hello, World!";
     sendto(s, msg, sizeof(msg),  0, (struct sockaddr*)addr, sizeof(struct sockaddr_in));
     return 0;
 }
 
 int server(int s, struct sockaddr_in * addr) {
     char buffer[32];
     size_t received;
 
     addr->sin_addr.s_addr = INADDR_ANY;
     if (bind(s, (struct sockaddr*)addr, sizeof(struct sockaddr_in)) < 0) {
         perror("bind");
         return -1;
     }
 
     received = recvfrom(s, buffer, sizeof(buffer) - 1, 0, NULL, 0);
     if (received < 0) {
         perror("recvfrom");
         return -1;
     }
 
     buffer[sizeof(buffer) - 1] = 0;
     printf("Got this: '%s'\n", buffer);
 
     return 0;
 }
 
 int main(int argc, const char *argv[]) {
     int s, val;
     struct sockaddr_in addr;
 
     if (argc == 1) {
         printf("Usage: %s <server|client> [addr]\n", argv[0]);
         return 0;
     }
     
     s = socket(AF_INET, SOCK_DGRAM, 0);   
     if (s < 0) {
         perror("socket");
         return -1;
     }
 
     val = 1;
     if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val)) < 0) {
         perror("setsockopt");
         close(s);
         return -1;
     }
 
     addr.sin_family = AF_INET;
     addr.sin_port = htons(PORT);
     if (argc > 2) {
         inet_aton(argv[2], &addr.sin_addr);
     }
 
     val = strcmp(argv[1], "server") == 0 ? server(s, &addr) : client(s, &addr);
 
     close(s);
 
     return val;
 }

Bruges således. På serveren (som skal modtage en besked):

$ ./b server
Got this: 'Hello, World!'
$

Og fra klienten, som sender beskeden:

$ ./b client 192.168.192.255
$

Jeg har kigget dit kode igennem paa kryds og tvaers men syntes ikke jeg kan faa mit til at broadcaste. Som sagt saa vil server og klient godt snakke sammen men kun en klient! Det ville vaere GULD vaerd hvis du hurtigt kunne skimte gennem mit kode og finde fejlen. Jeg har skrevet mit kode i en lille klasse. Her er headeren til klassen:

 #ifndef CLASS_SOCKET
 #define CLASS_SOCKET
 
 #pragma comment( lib, "Ws2_32.lib" )
 
 #define WIN32_LEAN_AND_MEAN
 #include <winsock2.h>
 #include <ws2tcpip.h>
 
 class CSocket
 {
    public:
      char Buffer[ 1024 ];
 
    CSocket( void );
    ~CSocket( void );
 
    bool Close( void );
    bool CreateBroadcast( const bool Server, const unsigned short Port, const char * IP );
    bool Created( void );
    bool Receive( void );
    bool Send( void );
 
    private:
      SOCKADDR_IN Addr;
      SOCKET Socket;
      unsigned short Port;
 
    bool SetOption( const int Level, const int Name, const char * Value, const int Length );
    bool SetupSocket( unsigned short Port );
 };
 
 #endif

og implementation i min cpp fil ser saaledes ud:

 #include "Socket.h"
 
 CSocket::CSocket( void )
 {
    for ( int I = 0; I < sizeof( Buffer ); I++ )
    Buffer[ I ] = 0;
 
    Port = 0;
    Socket = INVALID_SOCKET;
 }
 
 CSocket::~CSocket( void )
 {
    Close();
 }
 
 bool CSocket::Close( void )
 {
    if ( Socket != INVALID_SOCKET && closesocket( Socket ) == SOCKET_ERROR )
    {
       WSACleanup();
       return false;
    }
 
    WSACleanup();
    Socket = INVALID_SOCKET;
    return true;
 }
 
 bool CSocket::CreateBroadcast( const bool Server, const unsigned short Port, const char * IP )
 {
    if ( SetupSocket( Port ) )
    {
       if ( Server ) //Create server
       {
          Addr.sin_family = AF_INET;
          Addr.sin_port = htons( Port );
          Addr.sin_addr.s_addr = htonl( INADDR_ANY );
 
          //Bind the socket
          if ( bind( Socket, ( SOCKADDR * ) & Addr, sizeof( Addr ) ) != 0 )
          {
             Close();
             return false;
          }
       }
       else //Create client
         {
            Addr.sin_family = AF_INET;
            Addr.sin_port = htons( Port );
            Addr.sin_addr.s_addr = inet_addr( IP );
         }
 
       //Set broadcast option for client and server
       BOOL Flag = TRUE;
       if ( !SetOption( SOL_SOCKET, SO_BROADCAST, ( char * ) &Flag, sizeof( Flag ) ) )
       {
          Close();
          return false;
       }
       else
         return true;
    }
    else
      return false;
 }
 
 bool CSocket::Created( void )
 {
    if ( Socket == INVALID_SOCKET )
    return false;
    else
      return true;
 }
 
 bool CSocket::Receive( void )
 {
    int AddrSize = sizeof( Addr );
    if ( recvfrom( Socket, Buffer, sizeof( Buffer ), 0, ( SOCKADDR * ) & Addr, &AddrSize ) == SOCKET_ERROR )
    return false;
    else
      return true;
 }
 
 bool CSocket::Send( void )
 {
    if ( sendto( Socket, Buffer, sizeof( Buffer ), 0, ( SOCKADDR * ) & Addr, sizeof( Addr ) ) == SOCKET_ERROR )
    return false;
    else
      return true;
 }
 
 bool CSocket::SetOption( const int Level, const int Name, const char * Value, const int Length )
 {
    if ( setsockopt( Socket, Level, Name, Value, Length ) == SOCKET_ERROR )
    return false;
    else
      return true;
 }
 
 bool CSocket::SetupSocket( unsigned short Port )
 {
    if ( Port == 0 )
    return false;
 
    this->Port = Port;
 
    WSADATA Data;
    if ( WSAStartup( 0x0202, &Data ) != NO_ERROR )
    return false;
 
    Socket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
    if ( Socket == INVALID_SOCKET )
    {
       WSACleanup();
       return false;
    }
 
    return true;
 }

og til sidst ser min main fil saaledes ud:

 #include "Socket.h"
 
 #include <stdio.h>
 
 int main( int argc, char * argv[] )
 {
    CSocket Socket;
 
    bool Server = true; //<-- True for server and false for client!
 
    if ( Socket.CreateBroadcast( Server, 5555, "192.50.13.255" ) )
    {
       bool B = !Server;
 
       if ( Server )
       printf( "Waiting for client...\n" );
 
       while( true )
       {
          if ( !B )
          {
             if ( Socket.Receive() )
             {
                printf( "Data received!\n" );
                if ( Server )
                B = true;
             }
             else
               {
                  printf( "Error: %d\n", WSAGetLastError() );
                  break;
               }
          }
          else
            if ( Socket.Send() )
            {
               printf( "Data sent!\n" );
               if ( !Server )
               B = false;
            }
            else
              {
                 printf( "Error: %d\n", WSAGetLastError() );
                 break;
              }
 
          Sleep( 1000 );
       }
       Socket.Close();
    }
    else
      printf( "Error: %d\n", WSAGetLastError() );
 
    return 0;
 }

Paa forhaand 1000 tak

Jeg kan ikke umiddelbart se noget galt, men jeg har ikke en Windows maskine, som jeg kan teste på.

Har du tjekket med Wireshark, at der dukker noget op på den modtagende maskine ?

By the way...hvis det er en nyere Windows version er der muligvis nogle begrænsninger på brugerniveau. Har du prøvet at sende og modtage med en bruger med administrator rettigheder ?

Jeg har researchet lidt omkring emnet og det virker som om at Broadcast ikke rigtigt bliver brugt laengere. Sig endelig til, hvis jeg er forkert paa den! Multicast virker generalt til at vaere en mere fornuftig valg. Saa vidt jeg kan se saa bliver der sendt beskeder til alle paa netvaerket (uanset om de oensker beskederne eller ej) naar der Broadcastes. Multicast laver derimod en gruppe, hvor dem som oensker at modtage beskeder fra serveren, kan blive medlem af gruppen. Jeg kan ikke umiddelbart se nogen fordele at bruge Broadcasting fremfor Multicasting. Jeg kan fint faa Multicasting til at virke paa Windows, saa det er muligvis Windows der blokere for Broadcasting. Wiki skriver at alle Routers per default er sat til at blokere Broadcasting for at undgaa eventuelle DoS Attack eller lign. angreb som kan lamme et helt netvaerk.
Konklusion: Jeg vaelger Multicast

Men mange tak indsatsen!