]>
jfr.im git - irc/gameservirc.git/blob - gameserv/sockhelp.cpp
2 * This file is provided for use with the unix-socket-faq. It is public
3 * domain, and may be copied freely. There is no copyright on it. The
4 * original work was by Vic Metcalfe (vic@brutus.tlug.org), and any
5 * modifications made to that work were made with the understanding that
6 * the finished work would be in the public domain.
8 * If you have found a bug, please pass it on to me at the above address
9 * acknowledging that there will be no copyright on your work.
11 * The most recent version of this file, and the unix-socket-faq can be
12 * found at http://www.interlog.com/~vic/sock-faq/.
17 /* Take a service name, and a service type, and return a port number. If
19 service name is not found, it tries it as a decimal number. The number
20 returned is byte ordered for the network. */
21 int atoport(char *service
, char *proto
)
28 /* First try to read it from /etc/services */
29 serv
= getservbyname(service
, proto
);
32 else { /* Not in services, maybe a number? */
33 lport
= strtol(service
,&errpos
,0);
34 if ( (errpos
[0] != 0) || (lport
< 1) || (lport
> 65535) )
35 return -1; /* Invalid port address */
41 /* Converts ascii text to in_addr struct. NULL is returned if the address
43 struct in_addr
*atoaddr(char *address
)
46 static struct in_addr saddr
;
48 /* First try it as aaa.bbb.ccc.ddd. */
49 saddr
.s_addr
= inet_addr(address
);
50 if (saddr
.s_addr
!= 0) {
53 host
= gethostbyname(address
);
55 return (struct in_addr
*) *host
->h_addr_list
;
60 /* This function listens on a port, and returns connections. It forks
61 returns off internally, so your main function doesn't have to worry
62 about that. This can be confusing if you don't know what is going on.
63 The function will create a new process for every incoming connection,
64 so in the listening process, it will never return. Only when a
66 comes in, and we create a new process for it will the function return.
67 This means that your code that calls it should _not_ loop.
69 The parameters are as follows:
70 socket_type: SOCK_STREAM or SOCK_DGRAM (TCP or UDP sockets)
71 port: The port to listen on. Remember that ports < 1024 are
72 reserved for the root user. Must be passed in network byte
73 order (see "man htons").
74 listener: This is a pointer to a variable for holding the file
75 descriptor of the socket which is being used to listen. It
76 is provided so that you can write a signal handler to close
77 it in the event of program termination. If you aren't interested,
78 just pass NULL. Note that all modern unixes will close file
79 descriptors for you on exit, so this is not required. */
80 int get_connection(int socket_type
, u_short port
, int *listener
)
82 struct sockaddr_in address
;
84 int connected_socket
= -1;
88 /* Setup internet address information.
89 This is used with the bind() call */
90 memset((char *) &address
, 0, sizeof(address
));
91 address
.sin_family
= AF_INET
;
92 address
.sin_port
= port
;
93 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
95 listening_socket
= socket(AF_INET
, socket_type
, 0);
96 if (listening_socket
< 0) {
101 if (listener
!= NULL
)
102 *listener
= listening_socket
;
104 setsockopt(listening_socket
, SOL_SOCKET
, SO_REUSEADDR
, &reuse_addr
,
107 if (bind(listening_socket
, (struct sockaddr
*) &address
,
108 sizeof(address
)) < 0) {
110 close(listening_socket
);
114 if (socket_type
== SOCK_STREAM
) {
115 listen(listening_socket
, 5); /* Queue up to five connections before
116 having them automatically rejected. */
118 while(connected_socket
< 0) {
119 connected_socket
= accept(listening_socket
, NULL
, NULL
);
120 if (connected_socket
< 0) {
121 /* Either a real error occured, or blocking was interrupted for
122 some reason. Only abort execution if a real error occured. */
123 if (errno
!= EINTR
) {
125 close(listening_socket
);
128 continue; /* don't fork - do the accept again */
132 new_process
= fork();
133 if (new_process
< 0) {
135 close(connected_socket
);
136 connected_socket
= -1;
138 else { /* We have a new process... */
139 if (new_process
== 0) {
140 /* This is the new process. */
141 close(listening_socket
); /* Close our copy of this socket */
142 if (listener
!= NULL
)
143 *listener
= -1; /* Closed in this process. We are not
144 responsible for it. */
147 /* This is the main loop. Close copy of connected socket, and
149 close(connected_socket
);
150 connected_socket
= -1;
154 return connected_socket
;
157 return listening_socket
;
160 /* This is a generic function to make a connection to a given server/port.
161 service is the port name/number,
162 type is either SOCK_STREAM or SOCK_DGRAM, and
163 netaddress is the host name to connect to.
164 The function returns the socket, ready for action.*/
165 int make_connection(char *service
, int type
, char *netaddress
)
167 /* First convert service from a string, to a number... */
169 struct in_addr
*addr
;
171 struct sockaddr_in address
;
173 if (type
== SOCK_STREAM
)
174 port
= atoport(service
, "tcp");
175 if (type
== SOCK_DGRAM
)
176 port
= atoport(service
, "udp");
178 fprintf(stderr
,"make_connection: Invalid socket type.\n");
181 addr
= atoaddr(netaddress
);
183 fprintf(stderr
,"make_connection: Invalid network address.\n");
187 memset((char *) &address
, 0, sizeof(address
));
188 address
.sin_family
= AF_INET
;
189 address
.sin_port
= (port
);
190 address
.sin_addr
.s_addr
= addr
->s_addr
;
192 sock
= socket(AF_INET
, type
, 0);
194 printf("Connecting to %s on port %d.\n",inet_ntoa(*addr
),htons(port
));
196 if (type
== SOCK_STREAM
) {
197 connected
= connect(sock
, (struct sockaddr
*) &address
,
205 /* Otherwise, must be for udp, so bind to address. */
206 if (bind(sock
, (struct sockaddr
*) &address
, sizeof(address
)) < 0) {
213 /* This is just like the read() system call, accept that it will make
214 sure that all your data goes through the socket. */
215 int sock_read(int sockfd
, char *buf
, size_t count
)
217 size_t bytes_read
= 0;
220 while (bytes_read
< count
) {
222 this_read
= read(sockfd
, buf
, count
- bytes_read
);
223 while ( (this_read
< 0) && (errno
== EINTR
) );
226 else if (this_read
== 0)
228 bytes_read
+= this_read
;
234 /* This function reads from a socket, until it recieves a linefeed
235 character. It fills the buffer "str" up to the maximum size "count".
237 This function will return -1 if the socket is closed during the read
240 Note that if a single line exceeds the length of count, the extra data
241 will be read and discarded! You have been warned. */
242 int sock_gets(int sockfd
, char *str
, size_t count
)
245 unsigned int total_count
= 0;
246 char *current_position
;
249 current_position
= str
;
250 while (last_read
!= 10) {
251 bytes_read
= read(sockfd
, &last_read
, 1);
252 if (bytes_read
<= 0) {
253 /* The other side may have closed unexpectedly */
254 return -1; /* Is this effective on other platforms than linux? */
256 if ( (total_count
< count
) && (last_read
!= 10) && (last_read
!=13) )
258 current_position
[0] = last_read
;
264 current_position
[0] = 0;
268 /* This is just like the write() system call, accept that it will
269 make sure that all data is transmitted. */
270 int sock_write(int sockfd
, const char *buf
, size_t count
)
272 size_t bytes_sent
= 0;
275 while (bytes_sent
< count
) {
277 this_write
= write(sockfd
, buf
, count
- bytes_sent
);
278 while ( (this_write
< 0) && (errno
== EINTR
) );
281 bytes_sent
+= this_write
;
287 /* This function writes a character string out to a socket. It will
288 return -1 if the connection is closed while it is trying to write. */
289 int sock_puts(int sockfd
, const char *str
)
291 return sock_write(sockfd
, str
, strlen(str
));
294 /* This ignores the SIGPIPE signal. This is usually a good idea, since
295 the default behaviour is to terminate the application. SIGPIPE is
296 sent when you try to write to an unconnected socket. You should
297 check your return codes to make sure you catch this error! */
298 void ignore_pipe(void)
300 struct sigaction sig
;
302 sig
.sa_handler
= SIG_IGN
;
304 sigemptyset(&sig
.sa_mask
);
305 sigaction(SIGPIPE
,&sig
,NULL
);