/**
* @brief
* Makes a connection to the server, returning the pbs_connect() result.
*
* @param[in] server - hostname of the pbs server to connect to
* @param[in] extend - extend data to send along with the connection.
*
* @return int
* @retval connection success
* @retval 0 fail
*/
int
cnt2server_extend(char *server, char *extend)
{
int connect;
#if defined(PBS_SECURITY) && (PBS_SECURITY == KRB5)
if (!getenv("PBSPRO_IGNORE_KERBEROS") && !pbsgss_can_get_creds()) {
fprintf(stderr, "No Kerberos credentials found. Set \"PBSPRO_IGNORE_KERBEROS\" environment variable to skip this check.\n");
exit(1);
}
#endif
connect = pbs_connect_extend(server, extend);
if (connect <= 0) {
if (pbs_errno > PBSE_) {
switch (pbs_errno) {
case PBSE_BADHOST:
fprintf(stderr, "Unknown Host.\n");
break;
case PBSE_NOCONNECTS:
fprintf(stderr, "Too many open connections.\n");
break;
case PBSE_NOSERVER:
fprintf(stderr, "No default server name.\n");
break;
case PBSE_SYSTEM:
fprintf(stderr, "System call failure.\n");
break;
case PBSE_PERM:
fprintf(stderr, "No Permission.\n");
break;
case PBSE_PROTOCOL:
fprintf(stderr, "Communication failure.\n");
break;
}
} else if (errno != 0)
perror(NULL);
return (connect);
}
/*
* Disable Nagle's algorithm on the TCP connection to server.
* Nagle's algorithm is hurting cmd-server communication.
*/
if (pbs_connection_set_nodelay(connect) == -1) {
fprintf(stderr, "Cannot set nodelay on connection %d (errno=%d)\n",
connect, pbs_errno);
return (PBSE_SYSTEM);
}
return (connect);
}
/**
* @brief
* Makes a PBS_BATCH_Connect request to 'server'.
*
* @param[in] server - the hostname of the pbs server to connect to.
* @param[in] extend_data - a string to send as "extend" data.
*
* @return int
* @retval >= 0 index to the internal connection table representing the
* connection made.
* @retval -1 error encountered setting up the connection.
*/
int
__pbs_connect_extend(char *server, char *extend_data)
{
struct sockaddr_in server_addr;
struct sockaddr_in my_sockaddr;
int out;
int i;
int f;
char *altservers[2];
int have_alt = 0;
struct batch_reply *reply;
char server_name[PBS_MAXSERVERNAME+1];
unsigned int server_port;
struct sockaddr_in sockname;
pbs_socklen_t socknamelen;
#ifdef WIN32
struct sockaddr_in to_sock;
struct sockaddr_in from_sock;
#endif
#ifndef WIN32
char pbsrc[_POSIX_PATH_MAX];
struct stat sb;
int using_secondary = 0;
#endif /* not WIN32 */
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return -1;
if (pbs_loadconf(0) == 0)
return -1;
/* get server host and port */
server = PBS_get_server(server, server_name, &server_port);
if (server == NULL) {
pbs_errno = PBSE_NOSERVER;
return -1;
}
if (pbs_conf.pbs_primary && pbs_conf.pbs_secondary) {
/* failover configuered ... */
if (hostnmcmp(server, pbs_conf.pbs_primary) == 0) {
have_alt = 1;
/* We want to try the one last seen as "up" first to not */
/* have connection delays. If the primary was up, there */
/* is no .pbsrc.NAME file. If the last command connected */
/* to the Secondary, then it created the .pbsrc.USER file. */
/* see if already seen Primary down */
#ifdef WIN32
/* due to windows quirks, all try both in same order */
altservers[0] = pbs_conf.pbs_primary;
altservers[1] = pbs_conf.pbs_secondary;
#else
(void)snprintf(pbsrc, _POSIX_PATH_MAX, "%s/.pbsrc.%s", pbs_conf.pbs_tmpdir, pbs_current_user);
if (stat(pbsrc, &sb) == -1) {
/* try primary first */
altservers[0] = pbs_conf.pbs_primary;
altservers[1] = pbs_conf.pbs_secondary;
using_secondary = 0;
} else {
/* try secondary first */
altservers[0] = pbs_conf.pbs_secondary;
altservers[1] = pbs_conf.pbs_primary;
using_secondary = 1;
}
#endif
}
}
/* if specific host name declared for the host on which */
/* this client is running, get its address */
if (pbs_conf.pbs_public_host_name) {
if (get_hostsockaddr(pbs_conf.pbs_public_host_name, &my_sockaddr) != 0)
return -1; /* pbs_errno was set */
}
/* Reserve a connection state record */
if (pbs_client_thread_lock_conntable() != 0)
return -1;
out = -1;
for (i=1;i<NCONNECTS;i++) {
if (connection[i].ch_inuse) continue;
out = i;
connection[out].ch_errno = 0;
connection[out].ch_socket= -1;
connection[out].ch_errtxt = NULL;
connection[out].ch_inuse = 1; /* reserve the socket */
break;
}
if (pbs_client_thread_unlock_conntable() != 0)
return -1; /* pbs_errno set by the function */
if (out < 0) {
pbs_errno = PBSE_NOCONNECTS;
return -1;
}
/*
* connect to server ...
* If attempt to connect fails and if Failover configured and
* if attempting to connect to Primary, try the Secondary
* if attempting to connect to Secondary, try the Primary
*/
for (i=0; i<(have_alt+1); ++i) {
/* get socket */
#ifdef WIN32
/* the following lousy hack is needed since the socket call needs */
/* SYSTEMROOT env variable properly set! */
if (getenv("SYSTEMROOT") == NULL) {
setenv("SYSTEMROOT", "C:\\WINNT", 1);
setenv("SystemRoot", "C:\\WINNT", 1);
}
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
if (connection[out].ch_socket < 0) {
setenv("SYSTEMROOT", "C:\\WINDOWS", 1);
setenv("SystemRoot", "C:\\WINDOWS", 1);
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
}
#else
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
#endif
if (connection[out].ch_socket < 0) {
connection[out].ch_inuse = 0;
pbs_errno = errno;
return -1;
}
/* and connect... */
if (have_alt) {
server = altservers[i];
}
strcpy(pbs_server, server); /* set for error messages from commands */
/* If a specific host name is defined which the client should use */
if (pbs_conf.pbs_public_host_name) {
/* my address will be in my_sockaddr, bind the socket to it */
my_sockaddr.sin_port = 0;
if (bind(connection[out].ch_socket, (struct sockaddr *)&my_sockaddr, sizeof(my_sockaddr)) != 0) {
return -1;
}
}
if (get_hostsockaddr(server, &server_addr) != 0)
return -1;
server_addr.sin_port = htons(server_port);
if (connect(connection[out].ch_socket,
(struct sockaddr *)&server_addr,
sizeof(struct sockaddr)) == 0) {
break;
} else {
/* connect attempt failed */
CLOSESOCKET(connection[out].ch_socket);
pbs_errno = errno;
}
}
if (i >= (have_alt+1)) {
connection[out].ch_inuse = 0;
return -1; /* cannot connect */
}
#ifndef WIN32
if (have_alt && (i == 1)) {
/* had to use the second listed server ... */
if (using_secondary == 1) {
/* remove file that causes trying the Secondary first */
unlink(pbsrc);
} else {
/* create file that causes trying the Primary first */
f = open(pbsrc, O_WRONLY|O_CREAT, 0200);
if (f != -1)
(void)close(f);
}
}
#endif
/* setup connection level thread context */
if (pbs_client_thread_init_connect_context(out) != 0) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
/* pbs_errno set by the pbs_connect_init_context routine */
return -1;
}
/*
* No need for global lock now on, since rest of the code
* is only communication on a connection handle.
* But we dont need to lock the connection handle, since this
* connection handle is not yet been returned to the client
*/
/* The following code was originally put in for HPUX systems to deal
* with the issue where returning from the connect() call doesn't
* mean the connection is complete. However, this has also been
* experienced in some Linux ppc64 systems like js-2. Decision was
* made to enable this harmless code for all architectures.
* FIX: Need to use the socket to send
* a message to complete the process. For IFF authentication there is
* no leading authentication message needing to be sent on the client
* socket, so will send a "dummy" message and discard the replyback.
*/
#if !defined(PBS_SECURITY ) || (PBS_SECURITY == STD )
DIS_tcp_setup(connection[out].ch_socket);
if ((i = encode_DIS_ReqHdr(connection[out].ch_socket,
PBS_BATCH_Connect, pbs_current_user)) ||
(i = encode_DIS_ReqExtend(connection[out].ch_socket,
extend_data))) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
if (DIS_tcp_wflush(connection[out].ch_socket)) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
reply = PBSD_rdrpy(out);
PBSD_FreeReply(reply);
#endif /* PBS_SECURITY ... */
/*do configured authentication (kerberos, pbs_iff, whatever)*/
/*Get the socket port for engage_authentication() */
socknamelen = sizeof(sockname);
if (getsockname(connection[out].ch_socket, (struct sockaddr *)&sockname, &socknamelen))
return -1;
if (engage_authentication(connection[out].ch_socket,
server,
server_port,
&sockname) == -1) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PERM;
return -1;
}
/* setup DIS support routines for following pbs_* calls */
DIS_tcp_setup(connection[out].ch_socket);
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_VLONG; /* set for 3 hours */
/*
* Disable Nagle's algorithm on the TCP connection to server.
* Nagle's algorithm is hurting cmd-server communication.
*/
if (pbs_connection_set_nodelay(out) == -1) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_SYSTEM;
return -1;
}
return out;
}