/* Implement a simple-minded font authorization scheme. The authorization
name is "hp-hostname-1", the contents are simply the host name. */
int
set_font_authorizations(char **authorizations, int *authlen, pointer client)
{
#define AUTHORIZATION_NAME "hp-hostname-1"
#if defined(TCPCONN) || defined(STREAMSCONN)
static char *result = NULL;
static char *p = NULL;
if (p == NULL) {
char hname[1024], *hnameptr;
unsigned int len;
#if defined(IPv6) && defined(AF_INET6)
struct addrinfo hints, *ai = NULL;
#else
struct hostent *host;
#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
_Xgethostbynameparams hparams;
#endif
#endif
gethostname(hname, 1024);
#if defined(IPv6) && defined(AF_INET6)
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME;
if (getaddrinfo(hname, NULL, &hints, &ai) == 0) {
hnameptr = ai->ai_canonname;
}
else {
hnameptr = hname;
}
#else
host = _XGethostbyname(hname, hparams);
if (host == NULL)
hnameptr = hname;
else
hnameptr = host->h_name;
#endif
len = strlen(hnameptr) + 1;
result = malloc(len + sizeof(AUTHORIZATION_NAME) + 4);
p = result;
*p++ = sizeof(AUTHORIZATION_NAME) >> 8;
*p++ = sizeof(AUTHORIZATION_NAME) & 0xff;
*p++ = (len) >> 8;
*p++ = (len & 0xff);
memmove(p, AUTHORIZATION_NAME, sizeof(AUTHORIZATION_NAME));
p += sizeof(AUTHORIZATION_NAME);
memmove(p, hnameptr, len);
p += len;
#if defined(IPv6) && defined(AF_INET6)
if (ai) {
freeaddrinfo(ai);
}
#endif
}
// This is done here instead of in the constructor because
// gethostbyname can fail and I don't want things that can fail
// to be in a constructor.
static int
_cache_it(_Tt_hostname_cache_ptr cache_ptr, _Tt_string & hostname)
{
_Tt_hostname_cache_ptr sh, lh;
struct hostent *host_ret;
_Xgethostbynameparams host_buf;
char **h_addr_list;
memset((char*) &host_buf, 0, sizeof(_Xgethostbynameparams));
if ((host_ret = _XGethostbyname((char*) hostname, host_buf)) == NULL) {
return 0;
}
// cache the parts of the entry we're
// interested in. We have to do this
// since gethostbyname() returns a pointer
// to static memory, and since struct hostent's
// have pointers in them.
cache_ptr->addr_length = host_ret->h_length;
// Copy the list of IP addresses
for (h_addr_list = host_ret->h_addr_list;
h_addr_list;
h_addr_list++) {
if (! *h_addr_list) {
break; // no more addresses
}
// copy the address
_Tt_string new_addr((const unsigned char *)h_addr_list,
host_ret->h_length);
// cache it
cache_ptr->addr_list->append(new_addr);
}
return 1;
}
Boolean
XmuConvertStandardSelection(Widget w, Time time, Atom *selection, Atom *target,
Atom *type, XPointer *value,
unsigned long *length, int *format)
{
Display *d = XtDisplay(w);
if (*target == XA_TIMESTAMP(d)) {
*value = XtMalloc(4);
if (sizeof(long) == 4)
*(long*)*value = time;
else {
long temp = time;
(void) memmove((char*)*value, ((char*)&temp)+sizeof(long)-4, 4);
}
*type = XA_INTEGER;
*length = 1;
*format = 32;
return True;
}
if (*target == XA_HOSTNAME(d)) {
char hostname[1024];
hostname[0] = '\0';
*length = XmuGetHostname (hostname, sizeof hostname);
*value = XtNewString(hostname);
*type = XA_STRING;
*format = 8;
return True;
}
#if defined(TCPCONN)
if (*target == XA_IP_ADDRESS(d)) {
char hostname[1024];
#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
_Xgethostbynameparams hparams;
#endif
struct hostent *hostp;
hostname[0] = '\0';
(void) XmuGetHostname (hostname, sizeof hostname);
if ((hostp = _XGethostbyname (hostname,hparams)) == NULL)
return False;
if (hostp->h_addrtype != AF_INET) return False;
*length = hostp->h_length;
*value = XtMalloc(*length);
(void) memmove (*value, hostp->h_addr, *length);
*type = XA_NET_ADDRESS(d);
*format = 8;
return True;
}
#endif
#ifdef DNETCONN
if (*target == XA_DECNET_ADDRESS(d)) {
return False; /* XXX niy */
}
#endif
if (*target == XA_USER(d)) {
char *name = (char*)getenv("USER");
if (name == NULL) return False;
*value = XtNewString(name);
*type = XA_STRING;
*length = strlen(name);
*format = 8;
return True;
}
if (*target == XA_CLASS(d)) {
Widget parent = XtParent(w);
char *class;
int len;
while (parent != NULL && !isApplicationShell(w)) {
w = parent;
parent = XtParent(w);
}
if (isApplicationShell(w))
class = ((ApplicationShellWidget) w)->application.class;
else
static void
get_addr_by_name(const char *argtype,
const char *namestr,
int port,
int socktype, SOCKADDR_TYPE * addr, SOCKLEN_TYPE * addrlen
#if defined(IPv6) && defined(AF_INET6)
, struct addrinfo **aip, struct addrinfo **aifirstp
#endif
)
{
#if defined(IPv6) && defined(AF_INET6)
struct addrinfo *ai;
struct addrinfo hints;
char portstr[6];
char *pport = portstr;
int gaierr;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = socktype;
if (port == 0) {
pport = NULL;
}
else if (port > 0 && port < 65535) {
snprintf(portstr, sizeof(portstr), "%d", port);
}
else {
FatalError("Xserver: port out of range: %d\n", port);
}
if (*aifirstp != NULL) {
freeaddrinfo(*aifirstp);
*aifirstp = NULL;
}
if ((gaierr = getaddrinfo(namestr, pport, &hints, aifirstp)) == 0) {
for (ai = *aifirstp; ai != NULL; ai = ai->ai_next) {
if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6)
break;
}
if ((ai == NULL) || (ai->ai_addrlen > sizeof(SOCKADDR_TYPE))) {
FatalError("Xserver: %s host %s not on supported network type\n",
argtype, namestr);
}
else {
*aip = ai;
*addrlen = ai->ai_addrlen;
memcpy(addr, ai->ai_addr, ai->ai_addrlen);
}
}
else {
FatalError("Xserver: %s: %s %s\n", gai_strerror(gaierr), argtype,
namestr);
}
#else
struct hostent *hep;
#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
_Xgethostbynameparams hparams;
#endif
#if defined(WIN32) && defined(TCPCONN)
_XSERVTransWSAStartup();
#endif
if (!(hep = _XGethostbyname(namestr, hparams))) {
FatalError("Xserver: %s unknown host: %s\n", argtype, namestr);
}
if (hep->h_length == sizeof(struct in_addr)) {
memmove(&addr->sin_addr, hep->h_addr, hep->h_length);
*addrlen = sizeof(struct sockaddr_in);
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
}
else {
FatalError("Xserver: %s host on strange network %s\n", argtype,
namestr);
}
#endif
}
Xauth *
XauGetBestAuthByAddr (
#if NeedWidePrototypes
unsigned int family,
unsigned int address_length,
#else
unsigned short family,
unsigned short address_length,
#endif
_Xconst char* address,
#if NeedWidePrototypes
unsigned int number_length,
#else
unsigned short number_length,
#endif
_Xconst char* number,
int types_length,
char** types,
_Xconst int* type_lengths)
{
FILE *auth_file;
char *auth_name;
Xauth *entry;
Xauth *best;
int best_type;
int type;
#ifdef hpux
char *fully_qual_address;
unsigned short fully_qual_address_length;
#endif
auth_name = XauFileName ();
if (!auth_name)
return NULL;
if (access (auth_name, R_OK) != 0) /* checks REAL id */
return NULL;
auth_file = fopen (auth_name, "rb");
if (!auth_file)
return NULL;
#ifdef hpux
if (family == FamilyLocal) {
#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
_Xgethostbynameparams hparams;
#endif
struct hostent *hostp;
/* make sure we try fully-qualified hostname */
if ((hostp = _XGethostbyname(address,hparams)) != NULL) {
fully_qual_address = hostp->h_name;
fully_qual_address_length = strlen(fully_qual_address);
}
else
{
fully_qual_address = NULL;
fully_qual_address_length = 0;
}
}
#endif /* hpux */
best = NULL;
best_type = types_length;
for (;;) {
entry = XauReadAuth (auth_file);
if (!entry)
break;
/*
* Match when:
* either family or entry->family are FamilyWild or
* family and entry->family are the same and
* address and entry->address are the same
* and
* either number or entry->number are empty or
* number and entry->number are the same
* and
* either name or entry->name are empty or
* name and entry->name are the same
*/
if ((family == FamilyWild || entry->family == FamilyWild ||
(entry->family == family &&
((address_length == entry->address_length &&
binaryEqual (entry->address, address, (int)address_length))
#ifdef hpux
|| (family == FamilyLocal &&
fully_qual_address_length == entry->address_length &&
binaryEqual (entry->address, fully_qual_address,
(int) fully_qual_address_length))
#endif
))) &&
(number_length == 0 || entry->number_length == 0 ||
(number_length == entry->number_length &&
binaryEqual (entry->number, number, (int)number_length))))
{
if (best_type == 0)
{
best = entry;
break;
}
for (type = 0; type < best_type; type++)
if (type_lengths[type] == entry->name_length &&
!(strncmp (types[type], entry->name, entry->name_length)))
{
break;
}
if (type < best_type)
{
if (best)
XauDisposeAuth (best);
best = entry;
best_type = type;
if (type == 0)
break;
continue;
}
}
XauDisposeAuth (entry);
}
(void) fclose (auth_file);
return best;
}
_Tt_db_results _Tt_db_client::connectToDB (const _Tt_string &hostname)
{
_tt_auth_level_results *auth_level_results = (_tt_auth_level_results *)NULL;
int _socket;
_socket = -1;
dbHostname = hostname;
// Connect to the dbserver on the specified host.
// If we don't have TI_RPC we cannot depend on CLGET_FD, so
// we have to use clnttcp_create so that we get the socket FD back
// in order to set close_on_exec.
#if defined(OPT_TLI)
#ifdef OPT_HAS_CLNT_CREATE_TIMED
struct timeval tv = { OPT_CLNT_CREATE_TIMEOUT, 0};
dbServer = clnt_create_timed((char *)dbHostname,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
(char *)TT_DB_RPC_PROTO,
&tv);
#else
dbServer = clnt_create((char *)dbHostname,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
(char *)TT_DB_RPC_PROTO);
#endif
if (dbServer) {
clnt_control(dbServer, CLGET_FD, (char *)&_socket);
}
#else
struct sockaddr_in server_addr;
struct hostent *host_ret;
_Xgethostbynameparams host_buf;
memset((char*) &host_buf, 0, sizeof(_Xgethostbynameparams));
if ((host_ret = _XGethostbyname((char *)dbHostname, host_buf)) != NULL) {
_socket = RPC_ANYSOCK;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(0);
memcpy(&server_addr.sin_addr.s_addr,
*(host_ret->h_addr_list),
sizeof(server_addr.sin_addr.s_addr));
dbServer = clnttcp_create(&server_addr,
TT_DBSERVER_PROG,
TT_DBSERVER_VERS,
&_socket,
0, 0);
} else {
// gethostbyname failed, fake RPC error
dbServer = 0;
rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
}
#endif
// Connection failed.
if (!dbServer) {
_tt_syslog(0, LOG_ERR, catgets(_ttcatd, 1, 3,
"clnt_create for rpc.ttdbserverd on %s failed%s"),
(char *)dbHostname, clnt_spcreateerror(""));
// Set dbConnectionResults data member...
SetError(rpc_createerr.cf_stat);
return dbConnectionResults;
}
// Connection succeeded.
clnt_control(dbServer, CLSET_TIMEOUT, (char *)&TT_DB_RPC_QUICK_TIMEOUT);
dbConnectionResults = TT_DB_ERR_DB_CONNECTION_FAILED; // Default value.
for (;dbVersion > 0; dbVersion--) {
if (dbVersion > 1) {
auth_level_results =
_tt_get_min_auth_level_1 ((void *)NULL, dbServer);
} else {
// If dbVersion == 1, then we are talking to an old DB server
static _tt_auth_level_results results;
char *path = "";
clnt_stat rpc_status;
int *result = (int *)NULL;
result = _tt_min_auth_level_1(&path, dbServer, &rpc_status);
if (result) {
results.results = TT_DB_OK;
results.auth_level = *result;
auth_level_results = &results;
}
}
if ((auth_level_results) && (auth_level_results->results == TT_DB_OK)) {
clnt_control(dbServer, CLSET_TIMEOUT,
(char *)&TT_DB_RPC_NORMAL_TIMEOUT);
dbAuthLevel = auth_level_results->auth_level;
dbConnectionResults = TT_DB_OK; // Default return value.
switch (dbAuthLevel) {
case AUTH_NONE:
case AUTH_UNIX:
dbServer->cl_auth = authunix_create_default();
break;
#ifdef OPT_SECURE_RPC
case AUTH_DES: {
char server_net_name [MAXNETNAMELEN+1];
struct hostent *host_ret;
_Xgethostbynameparams host_buf;
if (host2netname(server_net_name, dbHostname, 0) &&
((host_ret = _XGethostbyname((char *)dbHostname, host_buf)) != NULL)) {
#ifdef OPT_TLI
dbServerNetName = server_net_name;
#else
memcpy((caddr_t) &dbSocket.sin_addr,
host_ret->h_addr,
host_ret->h_length);
dbSocket.sin_family = AF_INET;
dbSocket.sin_port = 0;
#endif
} else {
dbConnectionResults =
TT_DB_ERR_DB_CONNECTION_FAILED;
}
}
break;
#endif // OPT_SECURE_RPC
default:
dbConnectionResults =
TT_DB_ERR_DB_CONNECTION_FAILED;
break;
}
break;
} else {
// If _tt_get_min_auth_level_1 is not available, then we are talking
// to an old DB server.
if (_tt_get_rpc_result() != RPC_AUTHERROR) {
_tt_syslog(0, LOG_ERR,
catgets(_ttcatd, 1, 4, "Error: rpc.ttdbserverd on %s is not running"),
(char *)dbHostname);
SetError(_tt_get_rpc_result());
break; // Give up and return error code.
}
}
} // end -for()-
//
// Cleanup if failure.
//
if (dbConnectionResults != TT_DB_OK) {
if (dbServer) {
clnt_destroy(dbServer);
dbServer = (CLIENT *)NULL;
}
}
// Set close-on-exec bit so a libtt client which forks and execs won't
// be short some fd's in the child.
if (-1 != _socket && -1 == fcntl(_socket, F_SETFD, 1)) {
_tt_syslog( 0, LOG_ERR, "_Tt_db_client::connectToDb(): "
"fcntl(F_SETFD): %m");
}
return dbConnectionResults;
}