332 lines
8.9 KiB
C
332 lines
8.9 KiB
C
/* $Xorg: transport.c,v 1.4 2001/02/09 02:05:45 xorgcvs Exp $ */
|
|
/*
|
|
|
|
Copyright "1986-1997, 1998 The Open Group
|
|
|
|
Permission to use, copy, modify, distribute, and sell this software and its
|
|
documentation for any purpose is hereby granted without fee, provided that
|
|
the above copyright notice appear in all copies and that both that
|
|
copyright notice and this permission notice appear in supporting
|
|
documentation.
|
|
|
|
The above copyright notice and the following permission notice
|
|
shall be included in all copies of the Software:
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS ", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
|
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
|
|
AND NON-INFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE
|
|
FOR ANY CLAIM, DAMAGES OR OTHER SIABILITIY, WHETHER IN AN ACTION
|
|
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN
|
|
CONNNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of The Open Group
|
|
shall not be used in advertising or otherwise to promote the use
|
|
or other dealings in this Software without prior written
|
|
authorization from The Open Group.
|
|
|
|
X Window System is a trademark of The Open Group.
|
|
|
|
*/
|
|
/* $XFree86: xc/programs/xfwp/transport.c,v 1.6 2001/07/29 21:23:20 tsi Exp $ */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <X11/Xos.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/socket.h>
|
|
#include <netdb.h>
|
|
|
|
#include <X11/Xfuncs.h> /* Need for bzero() */
|
|
|
|
#include <X11/ICE/ICElib.h> /* Need typedef for Bool */
|
|
|
|
#include "xfwp.h"
|
|
#include "transport.h"
|
|
|
|
int
|
|
doSetupRemClientListen(
|
|
char ** listen_port_string,
|
|
struct clientDataStruct * program_data,
|
|
char * server_address)
|
|
{
|
|
int this_server;
|
|
int one = 1;
|
|
struct sockaddr_in rem_sockaddr_in;
|
|
int listen_port;
|
|
char hostname[MAX_HOSTNAME_LEN];
|
|
struct timeval time_val;
|
|
struct timezone time_zone;
|
|
int num_servers = program_data->config_info->num_servers;
|
|
|
|
/*
|
|
* ugh. This really shouldn't be kept as a sparse list but no time...
|
|
*/
|
|
for (this_server = 0;
|
|
this_server < num_servers && server_array[this_server] != NULL;
|
|
this_server++);
|
|
if (this_server == num_servers)
|
|
{
|
|
(void) fprintf(stderr,
|
|
"Maximum number of server connections has been reached (%d)\n",
|
|
program_data->config_info->num_servers);
|
|
return FAILURE;
|
|
}
|
|
|
|
/*
|
|
* offset listen port into the X protocol range;
|
|
* must be > X_SERVER_PORT_BASE < 65535
|
|
*/
|
|
listen_port = this_server + X_SERVER_PORT_BASE + 1;
|
|
|
|
/*
|
|
* allocate the server_array struct and init the fd elements;
|
|
* can't use the PM connection fd as an index into this array, since
|
|
* there could be multiple servers per PM connection
|
|
*/
|
|
if ((server_array[this_server] =
|
|
(struct server_list *) malloc(sizeof(struct server_list))) == NULL)
|
|
{
|
|
(void) fprintf(stderr,"malloc - server_array\n");
|
|
return FAILURE;
|
|
}
|
|
|
|
if ((server_array[this_server]->client_listen_fd =
|
|
socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
{
|
|
(void) fprintf(stderr,"socket call failed\n");
|
|
free(server_array[this_server]);
|
|
server_array[this_server] = NULL;
|
|
return FAILURE;
|
|
}
|
|
|
|
/*
|
|
* this is where we initialize the current time and timeout on this
|
|
* client_listen object
|
|
*/
|
|
gettimeofday(&time_val, &time_zone);
|
|
server_array[this_server]->creation_time = time_val.tv_sec;
|
|
server_array[this_server]->time_to_close =
|
|
global_data.config_info->client_listen_timeout;
|
|
|
|
/*
|
|
* set up the rest of the remote client listener
|
|
*/
|
|
bzero((char * ) &rem_sockaddr_in, sizeof(rem_sockaddr_in));
|
|
rem_sockaddr_in.sin_family = AF_INET;
|
|
#ifdef BSD44SOCKETS
|
|
rem_sockaddr_in.sin_len = sizeof rem_sockaddr_in;
|
|
#endif
|
|
|
|
#ifdef SO_REUSEADDR
|
|
if (setsockopt(server_array[this_server]->client_listen_fd,
|
|
SOL_SOCKET, SO_REUSEADDR,
|
|
(char *) &one, sizeof(int)) < 0)
|
|
{
|
|
(void) fprintf(stderr, "setsockopt(SO_REUSEADDR) failed\n");
|
|
returnFailure:
|
|
close(server_array[this_server]->client_listen_fd);
|
|
free(server_array[this_server]);
|
|
server_array[this_server] = NULL;
|
|
return FAILURE;
|
|
}
|
|
#endif /* SO_REUSEADDR */
|
|
|
|
while (True) {
|
|
rem_sockaddr_in.sin_port = htons(listen_port);
|
|
if (bind(server_array[this_server]->client_listen_fd,
|
|
(struct sockaddr *)&rem_sockaddr_in,
|
|
sizeof(rem_sockaddr_in)) == 0)
|
|
break;
|
|
if (errno != EADDRINUSE)
|
|
{
|
|
(void) fprintf(stderr,"bind call failed\n");
|
|
goto returnFailure;
|
|
}
|
|
listen_port++;
|
|
|
|
/*
|
|
* Cann't keep going forever.
|
|
*
|
|
* Why 65535 - it's the same value used by the LBXProxy.
|
|
*/
|
|
if (listen_port > 65535)
|
|
{
|
|
(void) fprintf(stderr,"failed to find a valid port for bind\n");
|
|
goto returnFailure;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
(void) fprintf (stderr, "Client connect port: %d\n", listen_port);
|
|
#endif
|
|
|
|
if (listen(server_array[this_server]->client_listen_fd, SOMAXCONN) < 0)
|
|
{
|
|
(void) fprintf(stderr, "listen call failed\n");
|
|
goto returnFailure;
|
|
}
|
|
|
|
/*
|
|
* update the nfds
|
|
*/
|
|
*(program_data->nfds) = max(*(program_data->nfds),
|
|
server_array[this_server]->client_listen_fd + 1);
|
|
|
|
/*
|
|
* get fully qualified name of host on which FWP is running
|
|
*/
|
|
if ((gethostname(hostname, MAX_HOSTNAME_LEN)) < 0)
|
|
{
|
|
(void) fprintf(stderr, "gethostname call failed\n");
|
|
goto returnFailure;
|
|
}
|
|
|
|
/*
|
|
* allocate and convert the listen_port string for return to PM;
|
|
* string equals address of host on which FWP is running
|
|
* plus ":<listen_port - X_SERVER_PORT_BASE> (up to xxx)"
|
|
*/
|
|
if (((*listen_port_string) =
|
|
(char *) malloc (strlen(hostname) + 10)) == NULL)
|
|
{
|
|
(void) fprintf(stderr, "malloc - proxy address\n");
|
|
goto returnFailure;
|
|
}
|
|
(void) sprintf (*listen_port_string, "%s:%d", hostname,
|
|
listen_port - X_SERVER_PORT_BASE);
|
|
|
|
/*
|
|
* add the server name associated with the current PM request
|
|
* to the list
|
|
*/
|
|
if ((server_array[this_server]->x_server_hostport =
|
|
strdup (server_address)) == NULL)
|
|
{
|
|
(void) fprintf(stderr, "malloc - server_array string\n");
|
|
free(*listen_port_string);
|
|
*listen_port_string = NULL;
|
|
goto returnFailure;
|
|
}
|
|
|
|
/*
|
|
* add the client listen port associated with the current PM connection
|
|
* to the list
|
|
*/
|
|
if ((server_array[this_server]->listen_port_string =
|
|
strdup (*listen_port_string)) == NULL)
|
|
{
|
|
(void) fprintf(stderr, "malloc - server_array string\n");
|
|
free(server_array[this_server]->x_server_hostport);
|
|
free(*listen_port_string);
|
|
*listen_port_string = NULL;
|
|
goto returnFailure;
|
|
}
|
|
|
|
/*
|
|
* set the select() read mask for this descriptor
|
|
*/
|
|
FD_SET(server_array[this_server]->client_listen_fd, program_data->rinit);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
void
|
|
doSelect(struct
|
|
config * config_info,
|
|
int * nfds,
|
|
int * nready,
|
|
fd_set * readable,
|
|
fd_set * writable)
|
|
{
|
|
if ((*nready = select(*nfds,
|
|
readable,
|
|
writable,
|
|
NULL,
|
|
&config_info->select_timeout)) == -1)
|
|
{
|
|
if (errno == EINTR)
|
|
return;
|
|
(void) fprintf(stderr, "select call failed\n");
|
|
perror("select");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
int
|
|
doServerConnectSetup(
|
|
char * x_server_hostport,
|
|
int * server_connect_fd,
|
|
struct sockaddr_in * server_sockaddr_in)
|
|
{
|
|
struct hostent * hostptr;
|
|
char * server_name_base;
|
|
char server_port_base[10];
|
|
int server_port;
|
|
int i = 0;
|
|
char * tmp_str;
|
|
char * tmp_hostport_str;
|
|
|
|
/*
|
|
* need to copy the host port string because strtok() changes it
|
|
*/
|
|
if ((tmp_hostport_str = strdup (x_server_hostport)) == NULL)
|
|
{
|
|
(void) fprintf(stderr, "malloc - hostport copy\n");
|
|
return FAILURE;
|
|
}
|
|
|
|
tmp_str = x_server_hostport;
|
|
while (tmp_str[i] != ':')
|
|
tmp_str++;
|
|
tmp_str++;
|
|
strcpy(server_port_base, tmp_str);
|
|
server_name_base = strtok(tmp_hostport_str,":");
|
|
server_port = atoi(server_port_base) + X_SERVER_PORT_BASE;
|
|
hostptr = gethostbyname(server_name_base);
|
|
free(tmp_hostport_str);
|
|
|
|
if (hostptr == NULL)
|
|
{
|
|
(void) fprintf(stderr, "gethostbyname call failed\n");
|
|
return FAILURE;
|
|
}
|
|
|
|
if ((*server_connect_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
{
|
|
(void) fprintf(stderr, "socket call for server failed: %s\n",
|
|
strerror(errno));
|
|
return FAILURE;
|
|
}
|
|
|
|
memset(server_sockaddr_in, 0, sizeof(*server_sockaddr_in));
|
|
server_sockaddr_in->sin_family = hostptr->h_addrtype;
|
|
#ifdef BSD44SOCKETS
|
|
server_sockaddr_in->sin_len = sizeof server_sockaddr_in;
|
|
#endif
|
|
memcpy((char *) &server_sockaddr_in->sin_addr,
|
|
hostptr->h_addr,
|
|
hostptr->h_length);
|
|
server_sockaddr_in->sin_port = htons(server_port);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
int
|
|
doServerConnect(
|
|
int * server_connect_fd,
|
|
struct sockaddr_in * server_sockaddr_in)
|
|
{
|
|
if(connect(*server_connect_fd, (struct sockaddr * )server_sockaddr_in,
|
|
sizeof(*server_sockaddr_in)) < 0)
|
|
{
|
|
(void) fprintf(stderr, "connect call to server failed: %s\n",
|
|
strerror(errno));
|
|
return FAILURE;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|