Sockets - The Error That Shouldn't Be There

[drdroid]

Ok, I've been learning out of this book, "Advanced Linux Programming," created by Code Sourcery. Now, it gives an example of creating, using and destroying sockets. I copied the source code completely, I even tried downloading the source code off of their website. But, I get these errors:


socket-server.cpp: In function `int main(int, char* const*)':

socket-server.cpp:75: cannot convert `sockaddr_un*' to `const sockaddr*' for
argument `2' to `int bind(int, const sockaddr*, unsigned int)'

socket-server.cpp:97: cannot convert `sockaddr_un' to `sockaddr*' for argument
`2' to `int accept(int, sockaddr*, socklen_t*)'



And here's the source code:


//socket-server.cpp
//Server of socket test

#include <iostream.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>

// Read text from the socket and print it out.
// Continue until the socket closes. Return
// nonzero if the client sent a "quit" message,
// zero otherwise.

int server(int client_socket)
{
while(1)
{
int length;
char* text;

// First, read the length of the text message
// from the socket. If read returns zero, the
// client closed the connection.

if(read(client_socket, &length, sizeof(length))==0)
{
return 0;
}


// Allocate a buffer to hold the text.

text=(char*)malloc(length);


// Read the text itself, and print it.

read(client_socket, text, length);
cout << text << endl;


// Free the buffer.

free(text);


// If the client sent the message "quit," we're all done.

if(!strcmp(text,"quit"))
{
return 1;
}
}
}

int main(int argc, char* const argv[])
{
const char* const socket_name=argv[1];
int socket_fd;
struct sockaddr_un name;
int client_sent_quit_message;

// Create the socket.

socket_fd=socket(PF_LOCAL, SOCK_STREAM, 0);


// Indicate that this is a server.

name.sun_family=AF_LOCAL;
strcpy(name.sun_path, socket_name);
bind(socket_fd,&name, SUN_LEN(&name));


// Listen for connections.

listen(socket_fd, 5);


// Repeatedly accept connections,
// spinning off one server() to deal with each
// client. Continue until a client sends a "quit"
// message.

do
{
struct sockaddr_un client_name;
socklen_t client_name_len;
int client_socket_fd;


// Accept a connection.

client_socket_fd=accept(socket_fd, client_name, &client_name_len);


// Handle the connection.

client_sent_quit_message=server(client_socket_fd);


// Close our end of the connection.

close(client_socket_fd);
}while(!client_sent_quit_message);


// Remove the socket file.

close(socket_fd);
unlink(socket_name);

return 0;
}

[twm]

Maybe you don't use the same Linux that they do. bind and accept take pointers to sockaddr, and my current system doesn't even recognize sockaddr_un or have it in any of the socket headers. Which leads me to believe that it's an extension...or a typo. :)