#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
-#ifdef HAVE_STRING_H
#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
/* Prototypes */
static afs_int32 afsconf_FindService(register const char *aname);
-static int TrimLine(char *abuffer);
+static int TrimLine(char *abuffer, int abufsize);
#ifdef AFS_NT40_ENV
static int IsClientConfigDirectory(const char *path);
static int GetCellNT(struct afsconf_dir *adir);
* CellServDB changes.
*/
+#if defined(AFS_SUN5_ENV) && !defined(__sparcv9)
+/* Solaris through 10 in 32 bit mode will return EMFILE if fopen can't
+ get an fd <= 255. We allow the fileserver to claim more fds than that.
+ This has always been a problem since pr_Initialize would have the same
+ issue, but hpr_Initialize makes it more likely that we would see this.
+ Work around it. This is not generic. It's coded with the needs of
+ afsconf_* in mind only.
+
+ http://www.opensolaris.org/os/community/onnv/flag-days/pages/2006042001/
+*/
+
+#define BUFFER 4096
+
+struct afsconf_iobuffer {
+ int _file;
+ char *buffer;
+ char *ptr;
+ char *endptr;
+};
+
+typedef struct afsconf_iobuffer afsconf_FILE;
+
+static afsconf_FILE *
+afsconf_fopen(const char *fname, const char *fmode)
+{
+ int fd;
+ afsconf_FILE *iop;
+
+ if ((fd = open(fname, O_RDONLY)) == -1) {
+ return NULL;
+ }
+
+ iop = malloc(sizeof(struct afsconf_iobuffer));
+ if (iop == NULL) {
+ (void) close(fd);
+ errno = ENOMEM;
+ return NULL;
+ }
+ iop->_file = fd;
+ iop->buffer = malloc(BUFFER);
+ if (iop->buffer == NULL) {
+ (void) close(fd);
+ free((void *) iop);
+ errno = ENOMEM;
+ return NULL;
+ }
+ iop->ptr = iop->buffer;
+ iop->endptr = iop->buffer;
+ return iop;
+}
+
+static int
+afsconf_fclose(afsconf_FILE *iop)
+{
+ if (iop == NULL) {
+ return 0;
+ }
+ close(iop->_file);
+ free((void *)iop->buffer);
+ free((void *)iop);
+ return 0;
+}
+
+static char *
+afsconf_fgets(char *s, int n, afsconf_FILE *iop)
+{
+ char *p;
+
+ p = s;
+ for (;;) {
+ char c;
+
+ if (iop->ptr == iop->endptr) {
+ ssize_t len;
+
+ if ((len = read(iop->_file, (void *)iop->buffer, BUFFER)) == -1) {
+ return NULL;
+ }
+ if (len == 0) {
+ *p = 0;
+ if (s == p) {
+ return NULL;
+ }
+ return s;
+ }
+ iop->ptr = iop->buffer;
+ iop->endptr = iop->buffer + len;
+ }
+ c = *iop->ptr++;
+ *p++ = c;
+ if ((p - s) == (n - 1)) {
+ *p = 0;
+ return s;
+ }
+ if (c == '\n') {
+ *p = 0;
+ return s;
+ }
+ }
+}
+#define fopen afsconf_fopen
+#define fclose afsconf_fclose
+#define fgets afsconf_fgets
+#else
+#define afsconf_FILE FILE
+#endif /* AFS_SUN5_ENV && ! __sparcv9 */
+
/* return port number in network byte order in the low 16 bits of a long; return -1 if not found */
static afs_int32
afsconf_FindService(register const char *aname)
struct servent *ts;
register struct afsconf_servPair *tsp;
-#if defined(AFS_OSF_ENV) || defined(AFS_DEC_ENV)
+#if defined(AFS_OSF_ENV)
ts = getservbyname(aname, "");
#else
ts = getservbyname(aname, NULL);
}
static int
-TrimLine(char *abuffer)
+TrimLine(char *abuffer, int abufsize)
{
char tbuffer[256];
register char *tp;
break;
tp++;
}
- strcpy(tbuffer, tp);
- strcpy(abuffer, tbuffer);
+ strlcpy(tbuffer, tp, sizeof tbuffer);
+ strlcpy(abuffer, tbuffer, abufsize);
return 0;
}
static int
afsconf_Check(register struct afsconf_dir *adir)
{
- char tbuffer[256];
+ char tbuffer[256], *p;
struct stat tstat;
register afs_int32 code;
#ifdef AFS_NT40_ENV
/* NT client CellServDB has different file name than NT server or Unix */
if (IsClientConfigDirectory(adir->name)) {
- strcompose(tbuffer, 256, adir->name, "/",
- AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ if (!afssw_GetClientCellServDBDir(&p)) {
+ strcompose(tbuffer, sizeof(tbuffer), p, "/",
+ AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ free(p);
+ } else {
+ int len;
+ strncpy(tbuffer, adir->name, sizeof(tbuffer));
+ len = (int)strlen(tbuffer);
+ if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
+ strncat(tbuffer, "\\", sizeof(tbuffer));
+ }
+ strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
+ sizeof(tbuffer));
+ tbuffer[sizeof(tbuffer) - 1] = '\0';
+ }
} else {
strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
NULL);
static int
afsconf_Touch(register struct afsconf_dir *adir)
{
- char tbuffer[256];
+ char tbuffer[256], *p;
#ifndef AFS_NT40_ENV
struct timeval tvp[2];
#endif
/* NT client CellServDB has different file name than NT server or Unix */
if (IsClientConfigDirectory(adir->name)) {
- strcompose(tbuffer, 256, adir->name, "/",
- AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ if (!afssw_GetClientCellServDBDir(&p)) {
+ strcompose(tbuffer, sizeof(tbuffer), p, "/",
+ AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ free(p);
+ } else {
+ int len = (int)strlen(tbuffer);
+ if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
+ strncat(tbuffer, "\\", sizeof(tbuffer));
+ }
+ strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
+ sizeof(tbuffer));
+ tbuffer[sizeof(tbuffer) - 1] = '\0';
+ }
} else {
strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
NULL);
register struct afsconf_dir *tdir;
register afs_int32 code;
- LOCK_GLOBAL_MUTEX
- /* zero structure and fill in name; rest is done by internal routine */
- tdir = (struct afsconf_dir *)malloc(sizeof(struct afsconf_dir));
+ LOCK_GLOBAL_MUTEX;
+ /* zero structure and fill in name; rest is done by internal routine */
+ tdir = (struct afsconf_dir *)malloc(sizeof(struct afsconf_dir));
memset(tdir, 0, sizeof(struct afsconf_dir));
- tdir->name = (char *)malloc(strlen(adir) + 1);
- strcpy(tdir->name, adir);
+ tdir->name = strdup(adir);
code = afsconf_OpenInternal(tdir, 0, 0);
if (code) {
if (!(afsconf_path = getenv("AFSCONF"))) {
/* The "AFSCONF" environment (or contents of "/.AFSCONF") will be typically set to something like "/afs/<cell>/common/etc" where, by convention, the default files for "ThisCell" and "CellServDB" will reside; note that a major drawback is that a given afs client on that cell may NOT contain the same contents... */
char *home_dir;
- FILE *fp;
+ afsconf_FILE *fp;
size_t len;
if (!(home_dir = getenv("HOME"))) {
fp = fopen("/.AFSCONF", "r");
if (fp == 0) {
free(tdir);
- UNLOCK_GLOBAL_MUTEX return (struct afsconf_dir *)0;
+ UNLOCK_GLOBAL_MUTEX;
+ return (struct afsconf_dir *)0;
}
fgets(afs_confdir, 128, fp);
fclose(fp);
fp = fopen("/.AFSCONF", "r");
if (fp == 0) {
free(tdir);
- UNLOCK_GLOBAL_MUTEX return (struct afsconf_dir *)0;
+ UNLOCK_GLOBAL_MUTEX;
+ return (struct afsconf_dir *)0;
}
}
fgets(afs_confdir, 128, fp);
len = strlen(afs_confdir);
if (len == 0) {
free(tdir);
- UNLOCK_GLOBAL_MUTEX return (struct afsconf_dir *)0;
+ UNLOCK_GLOBAL_MUTEX;
+ return (struct afsconf_dir *)0;
}
if (afs_confdir[len - 1] == '\n') {
afs_confdir[len - 1] = 0;
}
afsconf_path = afs_confdir;
}
- tdir->name = (char *)malloc(strlen(afsconf_path) + 1);
- strcpy(tdir->name, afsconf_path);
+ tdir->name = strdup(afsconf_path);
code = afsconf_OpenInternal(tdir, 0, 0);
if (code) {
free(tdir->name);
free(tdir);
- UNLOCK_GLOBAL_MUTEX return (struct afsconf_dir *)0;
+ UNLOCK_GLOBAL_MUTEX;
+ return (struct afsconf_dir *)0;
}
}
- UNLOCK_GLOBAL_MUTEX return tdir;
+ UNLOCK_GLOBAL_MUTEX;
+ return tdir;
}
-
static int
GetCellUnix(struct afsconf_dir *adir)
{
- int rc;
+ char *rc;
char tbuffer[256];
- FILE *tf;
-
+ char *start, *p;
+ afsconf_FILE *fp;
+
strcompose(tbuffer, 256, adir->name, "/", AFSDIR_THISCELL_FILE, NULL);
- tf = fopen(tbuffer, "r");
- if (tf) {
- /* FIXME: buffer overflow waiting to happen */
- rc = fscanf(tf, "%s", tbuffer);
- if (rc == 1) {
- adir->cellName = (char *)malloc(strlen(tbuffer) + 1);
- strcpy(adir->cellName, tbuffer);
- }
- fclose(tf);
- } else {
+ fp = fopen(tbuffer, "r");
+ if (fp == 0) {
return -1;
}
+ rc = fgets(tbuffer, 256, fp);
+ fclose(fp);
+ if (rc == NULL)
+ return -1;
+
+ start = tbuffer;
+ while (*start != '\0' && isspace(*start))
+ start++;
+ p = start;
+ while (*p != '\0' && !isspace(*p))
+ p++;
+ *p = '\0';
+ if (*start == '\0')
+ return -1;
+
+ adir->cellName = strdup(start);
return 0;
}
afsconf_OpenInternal(register struct afsconf_dir *adir, char *cell,
char clones[])
{
- FILE *tf;
+ afsconf_FILE *tf;
register char *tp, *bp;
register struct afsconf_entry *curEntry;
struct afsconf_aliasentry *curAlias;
char tbuffer[256], tbuf1[256];
struct stat tstat;
- /* figure out the cell name */
+ /* figure out the local cell name */
#ifdef AFS_NT40_ENV
i = GetCellNT(adir);
#else
*/
if (IsClientConfigDirectory(adir->name)) {
/* NT client config dir */
- strcompose(tbuffer, 256, adir->name, "/",
- AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ char *p;
+ if (!afssw_GetClientCellServDBDir(&p)) {
+ strcompose(tbuffer, sizeof(tbuffer), p, "/",
+ AFSDIR_CELLSERVDB_FILE_NTCLIENT, NULL);
+ free(p);
+ } else {
+ int len;
+ strncpy(tbuffer, adir->name, sizeof(tbuffer));
+ len = (int)strlen(tbuffer);
+ if (tbuffer[len - 1] != '\\' && tbuffer[len - 1] != '/') {
+ strncat(tbuffer, "\\", sizeof(tbuffer));
+ }
+ strncat(tbuffer, AFSDIR_CELLSERVDB_FILE_NTCLIENT,
+ sizeof(tbuffer));
+ tbuffer[sizeof(tbuffer) - 1] = '\0';
+ }
} else {
/* NT server config dir */
strcompose(tbuffer, 256, adir->name, "/", AFSDIR_CELLSERVDB_FILE,
adir->timeRead = 0;
}
- strcpy(tbuf1, tbuffer);
+ strlcpy(tbuf1, tbuffer, sizeof tbuf1);
tf = fopen(tbuffer, "r");
if (!tf) {
return -1;
tp = fgets(tbuffer, sizeof(tbuffer), tf);
if (!tp)
break;
- TrimLine(tbuffer); /* remove white space */
+ TrimLine(tbuffer, sizeof tbuffer); /* remove white space */
if (tbuffer[0] == 0 || tbuffer[0] == '\n')
continue; /* empty line */
if (tbuffer[0] == '>') {
free(curEntry);
return -1;
}
- if (linkedcell[0] != '\0') {
- curEntry->cellInfo.linkedCell =
- (char *)malloc(strlen(linkedcell) + 1);
- strcpy(curEntry->cellInfo.linkedCell, linkedcell);
- }
+ if (linkedcell[0] != '\0')
+ curEntry->cellInfo.linkedCell = strdup(linkedcell);
} else {
/* new host in the current cell */
if (!curEntry) {
tp = fgets(tbuffer, sizeof(tbuffer), tf);
if (!tp)
break;
- TrimLine(tbuffer); /* remove white space */
+ TrimLine(tbuffer, sizeof tbuffer); /* remove white space */
if (tbuffer[0] == '\0' || tbuffer[0] == '\n' || tbuffer[0] == '#')
continue; /* empty line */
curAlias = malloc(sizeof(*curAlias));
memset(curAlias, 0, sizeof(*curAlias));
- strcpy(curAlias->aliasInfo.aliasName, aliasPtr);
- strcpy(curAlias->aliasInfo.realName, tbuffer);
+ strlcpy(curAlias->aliasInfo.aliasName, aliasPtr, sizeof curAlias->aliasInfo.aliasName);
+ strlcpy(curAlias->aliasInfo.realName, tbuffer, sizeof curAlias->aliasInfo.realName);
curAlias->next = adir->alias_entries;
adir->alias_entries = curAlias;
/* call aproc(entry, arock, adir) for all cells. Proc must return 0, or we'll stop early and return the code it returns */
int
afsconf_CellApply(struct afsconf_dir *adir,
- int (*aproc) (struct afsconf_cell * cell, char *arock,
- struct afsconf_dir * dir), char *arock)
+ int (*aproc) (struct afsconf_cell * cell, void *arock,
+ struct afsconf_dir * dir), void *arock)
{
register struct afsconf_entry *tde;
register afs_int32 code;
- LOCK_GLOBAL_MUTEX for (tde = adir->entries; tde; tde = tde->next) {
+ LOCK_GLOBAL_MUTEX;
+ for (tde = adir->entries; tde; tde = tde->next) {
code = (*aproc) (&tde->cellInfo, arock, adir);
if (code) {
- UNLOCK_GLOBAL_MUTEX return code;
+ UNLOCK_GLOBAL_MUTEX;
+ return code;
}
}
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
/* call aproc(entry, arock, adir) for all cell aliases.
int
afsconf_CellAliasApply(struct afsconf_dir *adir,
int (*aproc) (struct afsconf_cellalias * alias,
- char *arock, struct afsconf_dir * dir),
- char *arock)
+ void *arock, struct afsconf_dir * dir),
+ void *arock)
{
register struct afsconf_aliasentry *tde;
register afs_int32 code;
- LOCK_GLOBAL_MUTEX for (tde = adir->alias_entries; tde; tde = tde->next) {
+ LOCK_GLOBAL_MUTEX;
+ for (tde = adir->alias_entries; tde; tde = tde->next) {
code = (*aproc) (&tde->aliasInfo, arock, adir);
if (code) {
- UNLOCK_GLOBAL_MUTEX return code;
+ UNLOCK_GLOBAL_MUTEX;
+ return code;
}
}
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
afs_int32 afsconf_SawCell = 0;
struct afsconf_cell *acellInfo)
{
afs_int32 code;
- int tservice, i;
- size_t len;
+ int tservice, i, len;
unsigned char answer[1024];
unsigned char *p;
+ char *dotcellname;
+ int cellnamelength;
char realCellName[256];
char host[256];
int server_num = 0;
int minttl = 0;
+ int try_init = 0;
/* The resolver isn't always MT-safe.. Perhaps this ought to be
* replaced with a more fine-grained lock just for the resolver
* operations.
*/
- LOCK_GLOBAL_MUTEX len =
- res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
- UNLOCK_GLOBAL_MUTEX if (len < 0)
- return AFSCONF_NOTFOUND;
+
+ retryafsdb:
+ if ( ! strchr(acellName,'.') ) {
+ cellnamelength=strlen(acellName);
+ dotcellname=malloc(cellnamelength+2);
+ memcpy(dotcellname,acellName,cellnamelength);
+ dotcellname[cellnamelength]='.';
+ dotcellname[cellnamelength+1]=0;
+ LOCK_GLOBAL_MUTEX;
+ len = res_search(dotcellname, C_IN, T_AFSDB, answer, sizeof(answer));
+ if ( len < 0 ) {
+ len = res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
+ }
+ UNLOCK_GLOBAL_MUTEX;
+ free(dotcellname);
+ } else {
+ LOCK_GLOBAL_MUTEX;
+ len = res_search(acellName, C_IN, T_AFSDB, answer, sizeof(answer));
+ UNLOCK_GLOBAL_MUTEX;
+ }
+ if (len < 0) {
+ if (try_init < 1) {
+ try_init++;
+ res_init();
+ goto retryafsdb;
+ }
+ return AFSCONF_NOTFOUND;
+ }
p = answer + sizeof(HEADER); /* Skip header */
code = dn_expand(answer, answer + len, p, host, sizeof(host));
* right AFSDB type. Write down the true cell name that
* the resolver gave us above.
*/
- strcpy(realCellName, host);
+ strlcpy(realCellName, host, sizeof realCellName);
}
code = dn_expand(answer, answer + len, p + 2, host, sizeof(host));
int tservice;
struct afsconf_entry DNSce;
afs_int32 cellHostAddrs[AFSMAXCELLHOSTS];
- char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
+ char cellHostNames[AFSMAXCELLHOSTS][MAXHOSTCHARS];
int numServers;
int rc;
int ttl;
DNSce.cellInfo.numServers = 0;
DNSce.next = NULL;
- rc = getAFSServer(acellName, cellHostAddrs, cellHostNames, &numServers, &ttl);
+ rc = getAFSServer(acellName, cellHostAddrs, cellHostNames, &numServers,
+ &ttl);
/* ignore the ttl here since this code is only called by transitory programs
* like klog, etc. */
if (rc < 0)
}
acellInfo->numServers = numServers;
- strcpy(acellInfo->name, acellName);
+ strlcpy(acellInfo->name, acellName, sizeof acellInfo->name);
if (aservice) {
- LOCK_GLOBAL_MUTEX tservice = afsconf_FindService(aservice);
- UNLOCK_GLOBAL_MUTEX if (tservice < 0) {
+ LOCK_GLOBAL_MUTEX;
+ tservice = afsconf_FindService(aservice);
+ UNLOCK_GLOBAL_MUTEX;
+ if (tservice < 0) {
return AFSCONF_NOTFOUND; /* service not found */
}
for (i = 0; i < acellInfo->numServers; i++) {
register afs_int32 i;
int tservice;
char *tcell;
- size_t cnLen;
+ int cnLen;
int ambig;
char tbuffer[64];
- LOCK_GLOBAL_MUTEX if (adir)
- afsconf_Check(adir);
+ LOCK_GLOBAL_MUTEX;
+ if (adir)
+ afsconf_Check(adir);
if (acellName) {
tcell = acellName;
- cnLen = strlen(tcell) + 1;
+ cnLen = (int)(strlen(tcell) + 1);
lcstring(tcell, tcell, cnLen);
afsconf_SawCell = 1; /* will ignore the AFSCELL switch on future */
/* call to afsconf_GetLocalCell: like klog */
} else {
i = afsconf_GetLocalCell(adir, tbuffer, sizeof(tbuffer));
if (i) {
- UNLOCK_GLOBAL_MUTEX return i;
+ UNLOCK_GLOBAL_MUTEX;
+ return i;
}
tcell = tbuffer;
}
bestce = (struct afsconf_entry *)0;
ambig = 0;
if (!adir) {
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
/* Look through the list of aliases */
if (aservice) {
tservice = afsconf_FindService(aservice);
if (tservice < 0) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_NOTFOUND; /* service not found */
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_NOTFOUND; /* service not found */
}
for (i = 0; i < acellInfo->numServers; i++) {
acellInfo->hostAddr[i].sin_port = tservice;
}
}
acellInfo->timeout = 0;
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
} else {
- UNLOCK_GLOBAL_MUTEX
+ UNLOCK_GLOBAL_MUTEX;
#ifdef AFS_AFSDB_ENV
- return afsconf_GetAfsdbInfo(tcell, aservice, acellInfo);
+ return afsconf_GetAfsdbInfo(tcell, aservice, acellInfo);
#else
- return AFSCONF_NOTFOUND;
+ return AFSCONF_NOTFOUND;
#endif /* AFS_AFSDB_ENV */
}
}
char *afscell_path;
afs_int32 code = 0;
- LOCK_GLOBAL_MUTEX
- /*
- * If a cell switch was specified in a command, then it should override the
- * AFSCELL variable. If a cell was specified, then the afsconf_SawCell flag
- * is set and the cell name in the adir structure is used.
- * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
- */
- if (!afsconf_SawCell && (afscell_path = getenv("AFSCELL"))) {
+ LOCK_GLOBAL_MUTEX;
+ /*
+ * If a cell switch was specified in a command, then it should override the
+ * AFSCELL variable. If a cell was specified, then the afsconf_SawCell flag
+ * is set and the cell name in the adir structure is used.
+ * Read the AFSCELL var each time: in case it changes (unsetenv AFSCELL).
+ */
+ if (!afsconf_SawCell && (afscell_path = getenv("AFSCELL"))) {
if (!afsconf_showcell) {
fprintf(stderr, "Note: Operation is performed on cell %s\n",
afscell_path);
code = AFSCONF_UNKNOWN;
}
- UNLOCK_GLOBAL_MUTEX return (code);
+ UNLOCK_GLOBAL_MUTEX;
+ return (code);
}
int
afsconf_Close(struct afsconf_dir *adir)
{
- LOCK_GLOBAL_MUTEX afsconf_CloseInternal(adir);
+ LOCK_GLOBAL_MUTEX;
+ afsconf_CloseInternal(adir);
if (adir->name)
free(adir->name);
free(adir);
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
static int
}
#endif /* AFS_NT40_ENV */
- LOCK_GLOBAL_MUTEX
- /* compute the key name and other setup */
- strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
+ LOCK_GLOBAL_MUTEX;
+ /* compute the key name and other setup */
+ strcompose(tbuffer, 256, adir->name, "/", AFSDIR_KEY_FILE, NULL);
tstr = (struct afsconf_keys *)malloc(sizeof(struct afsconf_keys));
adir->keystr = tstr;
fd = open(tbuffer, O_RDONLY);
if (fd < 0) {
tstr->nkeys = 0;
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
code = read(fd, tstr, sizeof(struct afsconf_keys));
close(fd);
if (code < sizeof(afs_int32)) {
tstr->nkeys = 0;
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
/* convert key structure to host order */
tstr->nkeys = ntohl(tstr->nkeys);
+
+ if (code < sizeof(afs_int32) + (tstr->nkeys*sizeof(struct afsconf_key))) {
+ tstr->nkeys = 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
+ }
+
for (fd = 0; fd < tstr->nkeys; fd++)
tstr->key[fd].kvno = ntohl(tstr->key[fd].kvno);
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
/* get keys structure */
{
register afs_int32 code;
- LOCK_GLOBAL_MUTEX code = afsconf_Check(adir);
+ LOCK_GLOBAL_MUTEX;
+ code = afsconf_Check(adir);
if (code) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_FAILURE;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_FAILURE;
}
memcpy(astr, adir->keystr, sizeof(struct afsconf_keys));
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
/* get latest key */
struct afsconf_key *bestk;
register afs_int32 code;
- LOCK_GLOBAL_MUTEX code = afsconf_Check(adir);
+ LOCK_GLOBAL_MUTEX;
+ code = afsconf_Check(adir);
if (code) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_FAILURE;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_FAILURE;
}
maxa = adir->keystr->nkeys;
memcpy(akey, bestk->key, 8); /* copy out latest key */
if (avno)
*avno = bestk->kvno; /* and kvno to caller */
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
- UNLOCK_GLOBAL_MUTEX return AFSCONF_NOTFOUND; /* didn't find any keys */
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_NOTFOUND; /* didn't find any keys */
}
/* get a particular key */
register struct afsconf_key *tk;
register afs_int32 code;
- LOCK_GLOBAL_MUTEX code = afsconf_Check(adir);
+ LOCK_GLOBAL_MUTEX;
+ code = afsconf_Check(adir);
if (code) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_FAILURE;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_FAILURE;
}
maxa = adir->keystr->nkeys;
for (tk = adir->keystr->key, i = 0; i < maxa; i++, tk++) {
if (tk->kvno == avno) {
memcpy(akey, tk->key, 8);
- UNLOCK_GLOBAL_MUTEX return 0;
+ UNLOCK_GLOBAL_MUTEX;
+ return 0;
}
}
- UNLOCK_GLOBAL_MUTEX return AFSCONF_NOTFOUND;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_NOTFOUND;
}
/* save the key structure in the appropriate file */
register afs_int32 i;
int foundSlot;
- LOCK_GLOBAL_MUTEX tk = adir->keystr;
+ LOCK_GLOBAL_MUTEX;
+ tk = adir->keystr;
if (akvno != 999) {
if (akvno < 0 || akvno > 255) {
- UNLOCK_GLOBAL_MUTEX return ERANGE;
+ UNLOCK_GLOBAL_MUTEX;
+ return ERANGE;
}
}
foundSlot = 0;
for (i = 0, tkey = tk->key; i < tk->nkeys; i++, tkey++) {
if (tkey->kvno == akvno) {
if (!overwrite) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_KEYINUSE;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_KEYINUSE;
}
foundSlot = 1;
break;
}
if (!foundSlot) {
if (tk->nkeys >= AFSCONF_MAXKEYS) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_FULL;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_FULL;
}
tkey = &tk->key[tk->nkeys++];
}
memcpy(tkey->key, akey, 8);
i = SaveKeys(adir);
afsconf_Touch(adir);
- UNLOCK_GLOBAL_MUTEX return i;
+ UNLOCK_GLOBAL_MUTEX;
+ return i;
}
/* this proc works by sliding the other guys down, rather than using a funny
register int i;
int foundFlag = 0;
- LOCK_GLOBAL_MUTEX tk = adir->keystr;
+ LOCK_GLOBAL_MUTEX;
+ tk = adir->keystr;
for (i = 0, tkey = tk->key; i < tk->nkeys; i++, tkey++) {
if (tkey->kvno == akvno) {
}
}
if (!foundFlag) {
- UNLOCK_GLOBAL_MUTEX return AFSCONF_NOTFOUND;
+ UNLOCK_GLOBAL_MUTEX;
+ return AFSCONF_NOTFOUND;
}
/* otherwise slide the others down. i and tkey point at the guy to delete */
tk->nkeys--;
i = SaveKeys(adir);
afsconf_Touch(adir);
- UNLOCK_GLOBAL_MUTEX return i;
+ UNLOCK_GLOBAL_MUTEX;
+ return i;
}
git://git.openafs.org / openafs.git / blobdiff