netselect.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Portions of this source code were derived from Berkeley 4.3 BSD
* under license from the Regents of the University of California.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "mt.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <netconfig.h>
#include <malloc.h>
#include <syslog.h>
#include "netcspace.h"
#include "nsl_stdio_prv.h"
#define FAILURE (unsigned)(-1)
/*
* Local routines used by the library procedures
*/
static int blank();
static int comment();
static struct netconfig *fgetnetconfig();
static void netconfig_free();
static unsigned int getflag();
static char **getlookups();
static struct netconfig **getnetlist();
static unsigned int getnlookups();
static char *gettoken();
static unsigned int getvalue();
static void shift1left();
static void netlist_free();
static void free_entry();
static struct netconfig *netconfig_dup();
/*
* System V routines used by the library procedures.
*/
extern char *getenv();
/* messaging stuff. */
extern const char __nsl_dom[];
extern char *dgettext(const char *, const char *);
/*
* Static global variables used by the library procedures:
*
* netpp - points to the beginning of the list of netconfig
* entries used by setnetconfig() and setnetpath().
* Once netpp is initialized, that memory is *never*
* released. This was necessary to improve performance.
*
* file (used for debugging and for nc_perror()).
*
* fieldnum - the current field number of the current line
* nc_perror()).
*
* nc_error - the error condition encountered.
*/
/*
* routines, which will always be executed once, and within the netpp_mutex.
* They are global to allow the nc_sperror routine to provide better
*/
static int linenum = 0; /* "owned" by getnetlist() */
static int fieldnum = 0; /* "owned" by fgetnetconfig() */
static int *
{
static pthread_key_t nc_error_key = 0;
static int nc_error = NC_NOERROR;
int *ret;
if (thr_main())
return (&nc_error);
/* if thr_get_storage fails we return the address of nc_error */
}
#define nc_error (*(__nc_error()))
/*
* setnetconfig() has the effect of "initializing" the
* network configuration database. It reads in the
* netcf entries (if not already read in).
*/
void *
{
trace1(TR_setnetconfig, 0);
return (NULL);
}
return (NULL);
}
return ((void *)retp);
}
/*
* endnetconfig() frees up all data allocated by setnetconfig()
*/
int
void *vdata;
{
trace1(TR_endnetconfig, 0);
return (-1);
}
free((void *)nconf_handlep);
return (0);
}
/*
* getnetconfig() returns the current entry in the list
* of netconfig structures. It uses the nconf_handlep argument
* to determine the current entry. If setnetconfig() was not
* called previously to set up the list, return failure.
* It also check if ipv6 interface is present(ipv6_present) and
* skips udp6 & tcp6 entries if ipv6 is not supported.
*/
struct netconfig *
void *vdata;
{
int ipv6_present = -1;
trace1(TR_getnetconfig, 0);
return (NULL);
}
for (;;) {
if (ipv6_present == -1)
if (!ipv6_present) {
++(nconf_handlep->nc_curr);
continue;
}
}
break;
}
++(nconf_handlep->nc_curr);
} else {
}
return (retp);
}
/*
* getnetconfig() searches the netconfig database for a
* given network id. Returns a pointer to the netconfig
* structure or a NULL if not found.
* It also check if ipv6 interface is present(ipv6_present) and
* skips udp6 & tcp6 entries if ipv6 is not supported.
*/
struct netconfig *
const char *netid;
{
int ipv6_present;
trace1(TR_getnetconfigent, 0);
return (NULL);
}
if (!ipv6_present) {
return (NULL);
}
}
return (netconfig_dup(*tpp));
}
}
return (NULL);
}
/*
* freenetconfigent frees the data allocated by getnetconfigent()
*/
void
{
}
/*
* getnetlist() reads the netconfig file and creates a
* NULL-terminated list of entries.
* Returns the pointer to the head of the list or a NULL
* on failure.
*/
static struct netconfig **
{
int count; /* the number of entries in file */
trace1(TR_getnetlist, 0);
return (NULL);
}
count = 0;
++count;
}
}
if (count == 0) {
(void) __nsl_fclose(fp);
return (NULL);
}
(void) __nsl_fclose(fp);
return (NULL);
}
/*
* The following loop fills in the list (loops until
* fgetnetconfig() returns a NULL) and counts the
* number of entries placed in the list. Note that
* when the loop is completed, the last entry in the
* list will contain a NULL (signifying the end of
* the list).
*/
linenum = 0;
;
(void) __nsl_fclose(fp);
return (listpp);
}
/*
* fgetnetconfig() parses a line of the netconfig file into
* a netconfig structure. It returns a pointer to the
* structure of success and a NULL on failure or EOF.
*/
static struct netconfig *
__NSL_FILE *fp;
char *netid;
{
char *retvalp; /* the return value of fgets() */
char *entnetid; /* netid for the current entry */
trace1(TR_fgetnetconfig, 0);
/* skip past blank lines and comments. */
linenum++;
break;
}
}
return (NULL);
}
fieldnum = 0;
return (NULL);
}
return (NULL);
}
if ((netconfigp = (struct netconfig *)
return (NULL);
}
((netconfigp->nc_semantics =
netconfigp = NULL;
}
return (netconfigp);
}
/*
* setnetpath() has the effect of "initializing" the
* NETPATH variable. It reads in the netcf entries (if not
* already read in), creates a list corresponding to the entries
* in the NETPATH variable (or the "visible" entries og netconfig
* if NETPATH is not set).
*/
void *
{
int count; /* the number of entries in NETPATH */
char *netpath; /* value of NETPATH from environment */
char *netid; /* holds a component of NETPATH */
char *tp; /* used to scan NETPATH string */
trace1(TR_setnetpath, 0);
/*
* Read in the netconfig database if not already read in
*/
return (NULL);
}
return (NULL);
}
/*
* Get the valid entries of the NETPATH variable (and
* count the number of entries while doing it).
*
* This is done every time the procedure is called just
* in case NETPATH has changed from call to call.
*
* If NETPATH is too long, we ignore it altogether as
* it can only be a buffer overflow attack.
* Since we add one colon for each entry, but colons only
* need to exist between entries, we have to subtract one.
*/
count = 0;
valid_netpath[0] = '\0';
/*
* If NETPATH variable is not set or invalid,
* the valid NETPATH consist of all "visible"
* netids from the netconfig database.
*/
count++;
}
}
} else {
/*
* Copy the value of NETPATH (since '\0's will be
* put into the string) and create the valid NETPATH
* (by throwing away all netids not in the database).
* If an entry appears more than one, it *will* be
* listed twice in the list of valid netpath entries.
*/
while (*tp) {
/* Skip all leading ':'s */
tp++;
break; /* last one */
tp++;
if (*tp)
(void) strcat(valid_netpath,
count++;
break;
}
}
}
}
/* Get space to hold the valid list (+1 for the NULL) */
return (NULL);
}
/*
* Populate the NETPATH list, ending it with a NULL.
* Each entry in the list points to the structure in the
* "netpp" list (the entry must exist in the list, otherwise
* it wouldn't appear in valid_netpath[]).
*/
while (*tp) {
tp++;
if (*tp)
*tp++ = '\0';
break;
}
}
}
return ((void *)retp);
}
/*
* endnetpath() frees up all of the memory allocated by setnetpath().
* It returns -1 (error) if setnetpath was never called.
*/
int
void *vdata;
{
/* The argument is really a NCONF_HANDLE; cast it here */
trace1(TR_endnetpath, 0);
return (-1);
}
return (0);
}
/*
* getnetpath() returns the current entry in the list
* from the NETPATH variable. If setnetpath() was not called
* previously to set up the list, return NULL.
*/
struct netconfig *
void *vdata;
{
/* The argument is really a NCONF_HANDLE; cast it here */
int ipv6_present = -1;
trace1(TR_getnetpath, 0);
return (NULL);
}
for (;;) {
if (ipv6_present == -1)
if (!ipv6_present) {
++(nconf_handlep->nc_curr);
continue;
}
}
break;
}
if (retp) {
++(nconf_handlep->nc_curr);
} else {
}
return (retp);
}
/*
* blank() returns true if the line is a blank line, 0 otherwise
*/
static int
char *cp;
{
cp++;
}
return (*cp == '\0');
}
/*
* comment() returns true if the line is a comment, 0 otherwise.
*/
static int
char *cp;
{
trace1(TR_comment, 0);
cp++;
}
return (*cp == '#');
}
/*
* getvalue() searches for the given string in the given array,
* and return the integer value associated with the string.
*/
static unsigned int
char *cp;
{
int i; /* used to index through the given struct nc_data array */
trace1(TR_getvalue, 0);
break;
}
}
}
/*
* getflag() creates a bitmap of the one-character flags in
* the given string. It uses nc_flags array to get the values.
*/
static unsigned int
char *cp;
{
int i; /* indexs through the nc_flag array */
unsigned int mask = 0; /* holds bitmask of flags */
trace1(TR_getflag, 0);
while (*cp) {
break;
}
}
cp++;
}
return (mask);
}
/*
* getlookups() creates and returns an array of string representing
* the directory lookup libraries, given as a comma-seperated list
* in the argument "cp".
*/
static char **
char *cp;
{
unsigned int num; /* holds the number of entries in the list */
char **listpp; /* the beginning of the list of dir routines */
char **tpp; /* traverses the list, populating it */
char *start;
trace1(TR_getlookups, 0);
if (num == 0) {
return (NULL);
}
return (NULL);
}
while (num--) {
/*
* Traverse the string looking for the next entry
* of the list (i.e, where the ',' or end of the
* string appears). If a "\" is found, shift the
* token over 1 to the left (taking the next char
* literally).
*/
shift1left(cp);
}
cp++;
}
if (*cp)
*cp++ = '\0';
return (NULL);
}
}
return (listpp);
}
/*
* getnlookups() returns the number of entries in a comma-separated
* string of tokens. A "-" means no strings are present.
*/
static unsigned int
char *cp;
{
unsigned int count; /* the number of tokens in the string */
trace1(TR_getnlookups, 0);
return (0);
}
count = 1;
while (*cp) {
if (*cp == ',') {
count++;
}
/*
* If a "\" is in the string, take the next character
* literally. Onlly skip the character if "\" is
* not the last character of the token.
*/
cp++;
}
cp++;
}
return (count);
}
/*
* gettoken() behaves much like strtok(), except that
* it knows about escaped space characters (i.e., space characters
* preceeded by a '\' are taken literally).
*/
static char *
char *cp;
int skip;
{
static char *savep; /* the place where we left off */
char *p; /* the beginning of the new token */
char *retp; /* the token to be returned */
trace1(TR_gettoken, 0);
fieldnum++;
/* Determine if first or subsequent call */
/* Return if no tokens remain. */
if (p == 0) {
return (NULL);
}
while (isspace(*p))
p++;
if (*p == '\0') {
return (NULL);
}
/*
* Save the location of the token and then skip past it
*/
retp = p;
while (*p) {
if (isspace(*p))
shift1left(p);
continue;
} else
break;
/*
* Only process the escape of the space seperator;
* since the token may contain other separators,
* let the other routines handle the escape of
* specific characters in the token.
*/
shift1left(p);
}
p++;
}
if (*p == '\0') {
savep = 0; /* indicate this is last token */
} else {
*p = '\0';
savep = ++p;
}
}
/*
* shift1left() moves all characters in the string over 1 to
* the left.
*/
static void
shift1left(p)
char *p;
{
trace1(TR_shift1left, 0);
for (; *p; p++)
*p = *(p + 1);
}
char *
{
static pthread_key_t perror_key;
buf_main :
trace1(TR_nc_sperror, 0);
"nc_sperror: malloc failed when trying to create buffer\n");
return (NULL);
}
switch (nc_error) {
case NC_NOERROR:
break;
case NC_NOMEM:
BUFSIZ);
break;
case NC_NOSET:
"routine called before calling \
setnetpath() or setnetconfig()"), BUFSIZ);
break;
case NC_OPENFAIL:
BUFSIZ);
break;
case NC_BADLINE:
break;
case NC_NOTFOUND:
break;
case NC_NOMOREENTRIES:
break;
default:
BUFSIZ);
break;
}
return (retstr);
}
void
{
trace1(TR_nc_perror, 0);
if (string)
else
}
static void
{
trace1(TR_netlist_free, 0);
}
}
static void
struct netconfig *netconfigp;
{
int i;
trace1(TR_netconfig_free, 0);
if (netconfigp == NULL) {
return;
}
if (netconfigp->nc_lookups)
for (i = 0; i < netconfigp->nc_nlookups; i++)
}
static struct netconfig *
struct netconfig *netconfigp;
{
int i;
trace1(TR_netconfig_dup, 0);
return (NULL);
}
* sizeof (char *));
return (NULL);
}
for (i = 0; i < netconfigp->nc_nlookups; i++) {
nconf->nc_nlookups = i;
return (NULL);
}
}
return (nconf);
}
static void
void *foo;
{
trace1(TR_free_entry, 0);
if (foo)
}