void authtoken_init()
{
char buf1[512], buf2[512];
char t1[128/8], t2[128/8];
struct stat stat_buf;
FILE *fp=fopen(RANDTOKENFILE, "r");
time(&expire_time);
if (fp)
{
if (fgets(buf1, sizeof(buf1), fp) &&
fgets(buf2, sizeof(buf2), fp))
{
char *p;
if ((p=strchr(buf1, '\n')) != NULL)
*p=0;
if ((p=strchr(buf2, '\n')) != NULL)
*p=0;
/* Determine if the saved tokens are kosher */
if (strlen(buf1) == 32 &&
strlen(buf2) == 32 &&
goodtoken(buf1, t1) == 0 &&
goodtoken(buf2, t2) == 0 &&
fstat(fileno(fp), &stat_buf) == 0 &&
/* Haven't expired (+tolerate clock adjustments) */
stat_buf.st_mtime < expire_time + 60 &&
stat_buf.st_mtime >= expire_time - TIMEOUT*2)
{
expire_time=stat_buf.st_mtime + TIMEOUT*2;
memcpy(prev_token, t1, sizeof(t1));
memcpy(cur_token, t2, sizeof(t2));
fclose(fp);
fprintf(stderr, "NOTICE: restored saved authentication tokens\n");
return;
}
}
fclose(fp);
}
newtoken(prev_token);
newtoken(cur_token);
expire_time += TIMEOUT*2;
savetokens();
}
/* CONTEXT: Determine whether a GI is valid in the present structural context.
Returns RCHIT if valid, RCEND if element has ended, RCREQ if a
different element is required, and RCMISS if it is totally invalid.
On entry, pos points to the model token to be tested against the GI.
TO DO: Save allowed GIs for an error message on an RCMISS.
Support a "query" mode (what is allowed now?) by working
with a copy of pos.
*/
int context(struct etd *gi, /* ETD of new GI. */
struct thdr mod[], /* Model of current open element. */
struct mpos pos[], /* Position in open element's model. */
UNCH *statuspt, /* Token status: RCHIT RCMISS RCEND RCREQ RCNREQ*/
int mexts) /* >0=stack level of minus grp; -1=plus; 0=none.*/
{
UNCH toccsv, gtypesv; /* Save token's TOCC and GTYPE in case grp ends.*/
if (mexts == -1) {
if (STATUS == RCEND)
return RCPEX;
copypos(savedpos, pos);
}
Tstart = T; /* Save starting token for AND group testing. */
while (STATUS!=RCMISS && STATUS!=RCEND) {
TRACEGI("CONTEXT", gi, mod, pos, Tstart);
while (TTYPE==TTOR || TTYPE==TTSEQ || TTYPE==TTAND) {
pos[P+1].g = M++; pos[++P].t = 1; HITCLEAR(H);
Tstart = T; /* Save starting token for AND group testing. */
TRACEGI("OPENGRP", gi, mod, pos, Tstart);
}
STATUS = (UNCH)tokenreq(gi, mod, pos);
TRACEGI("STATUS", gi, mod, pos, Tstart);
if (gi==TOKEN.tu.thetd) { /* Hit in model. */
STATUS = (UNCH)RCHIT;
gtypesv = GTYPE; toccsv = TOCC;
newtoken(mod, pos, statuspt);
return(mexts<=0 ? RCHIT : (gtypesv==TTOR || BITON(toccsv, TOPT))
? RCMEX : RCHITMEX);
}
if (STATUS==RCREQ) {
if (mexts == -1) break;
STATUS = RCHIT;
nextetd = TOKEN.tu.thetd;
newtoken(mod, pos, statuspt);
return(RCREQ);
}
/* else if (STATUS==RCNREQ) */
if (mexts>0) return(RCMEX);
newtoken(mod, pos, statuspt);
}
if (mexts == -1) {
copypos(pos, savedpos);
return STATUS = RCPEX;
}
return((int)STATUS);
}
token *
lex()
{
static char *word = NULL;
token *result;
char *p;
result = newtoken();
if (!word || *word == 0) {
word = getword();
if (!word) {
result->type = 0;
if (D_valsi)
printf("valsi: end of text\n");
return result;
}
}
if (iscmene(word)) {
result->type = CMENE_518;
result->text = newstring(strlen(word) + 1);
memcheck(result->text, "text");
strcpy(result->text, word);
word = NULL;
}
else if (isbrivla(word)) {
result->type = BRIVLA_509;
result->text = newstring(strlen(word) + 1);
memcheck(result->text, "text");
strcpy(result->text, word);
word = NULL;
}
else {
for (p = word + 1; *p; p++)
if (isC(*p)) break;
result->text = newstring(p - word + 1);
memcheck(result->text, "text");
strncpy(result->text, word, p - word);
result->text[p-word] = 0;
word = p;
}
if (D_valsi) {
printf("valsi: ");
print(result);
}
return result;
}
static struct token*
clone_token(struct token *stok)
{
struct token*tp = newtoken();
*tp = *stok;
if (curr_lang)
{
tp->lang = curr_lang;
texttag_register(curr_lang->fulltag);
}
else
{
tp->lang = global_lang;
}
return tp;
}
time_t authtoken_check()
{
time_t now;
time(&now);
if (now < expire_time && now >= expire_time - TIMEOUT*4)
return (expire_time - now);
memcpy(prev_token, cur_token, sizeof(cur_token));
newtoken(cur_token);
savetokens();
now += TIMEOUT*2;
expire_time=now;
return (TIMEOUT*2);
}
/* Create a new NFS request of type specified */
static
NFS_BaseRequest *
create_request(enum NfsRequestType rt, VNode vn, pid_t pid) {
dprintf(2, "create request: %d %p %d\n", rt, vn, pid);
NFS_BaseRequest *rq;
switch (rt) {
case RT_LOOKUP:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_LookupRequest));
break;
case RT_READ:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_ReadRequest));
break;
case RT_WRITE:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_WriteRequest));
break;
case RT_STAT:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_StatRequest));
break;
case RT_DIR:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_DirRequest));
break;
case RT_REMOVE:
rq = (NFS_BaseRequest *) malloc(sizeof(NFS_RemoveRequest));
break;
default:
dprintf(0, "!!! nfsfs_create_request: invalid request type %d\n", rt);
return NULL;
}
if (rq == NULL) {
dprintf(0, "!!! nfsfs_create_request: Malloc failed! (type %d)\n", rt);
return NULL;
}
rq->rt = rt;
rq->token = newtoken();
rq->vnode = vn;
rq->pid = pid;
// add to list
list_push(NfsRequests, rq);
return rq;
}
struct prsstack *gettok() /*;gettok*/
{
/* Gettok: Scan and return the next token in the adafile, adding the */
/* token to namelist. */
static int nextcanbeprime = 0; /* The next token can be a prime */
static int canbeprime; /* The current token can be a prime */
struct prsstack *tok; /* Token to be returned */
while (1) {
while (1) {
while (*line == ' ' || *line == '\t') {
colno += (*line == '\t') ? (8 - ((colno - 1) % 8)) : 1;
line++;
}
if (!*line || *line == '-' && line[1] == '-')
break;
canbeprime = nextcanbeprime;
nextcanbeprime = 0;
if (isalpha(*line)) { /* Scan identifiers */
char id[MAXLINE + 1];
int idind = 0, chread = 0;
int tokind, toksym;
scanidorint(id, &idind, &chread, isletterordigit, 0);
if (id[idind - 1] == '_')
idind--;
id[idind] = '\0';
convtoupper(id);
tokind = namemap(id, idind);
toksym = MIN(tokind, ID_SYM);
tok = newtoken(toksym, tokind, lineno, colno);
nextcanbeprime = toksym == ID_SYM || toksym == RANGE_SYM
|| toksym == ALL_SYM;
colno += chread;
line += chread;
return(tok);
}
else if (isdigit(*line) || *line == '.' && isdigit(line[1])) {
/* Scan numeric literals */
char num[MAXLINE + 3];
int ind = 0, chread = 0, result;
char ch;
/* ind is the index into the num string */
/* chread is the index into the line input string */
result = scandec(num, &ind, &chread, isdecimal);
ch = line[chread];
if (result == 1 && (ch == '#' || ch == ':')) {
/* Scan for the rest of a based literal */
num[ind++] = '#';
chread++;
if (!scandec(num, &ind, &chread, ishex)) {
lexerr(lineno, colno + chread - 1, colno + chread - 1,
"Incomplete based number");
num[ind++] = '0';
}
num[ind++] = '#';
if (line[chread] != ch) {
if (line[chread] == '#' + ':' - ch) {
lexerr(lineno, colno + chread, colno + chread,
"Expect #'s or :'s in based number to match");
chread++;
}
else {
char msg[50];
sprintf(msg, "Expect '%c' after last digit", ch);
lexerr(lineno, colno + chread - 1,
colno + chread - 1, msg);
}
}
else
chread++;
checkbased(num, &ind);
}
scanexp(num, &ind, &chread);
if (isalpha(line[chread]))
lexerr(lineno, colno, colno + chread - 1,
"Number should be separated from adjacent identifier");
num[ind] = '\0';
tok = newtoken(NUMBER_SYM, namemap(num, ind), lineno, colno);
colno += chread;
line += chread;
return(tok);
}
else if (*line == '\'') {
int err = 0;
if (line[1] != '\0' && line[2] == '\'' &&
(!canbeprime || line[1] != '(')) {
/* Scan a character literal */
char str[4];
int len = 3;
strcpy(str, "' '");
if (!isprint(line[1]) && line[1] != ' ') {
char msg[80];
sprintf(msg,
"Invalid character %s in character literal replaced by space",
nonprintingmsg[line[1]]);
lexerr(lineno, colno + 1, colno + 1, msg);
len = (line[1] == '\t') ? (10 - (colno % 8)) : 2;
}
else
str[1] = line[1];
tok = newtoken(CHAR_SYM, namemap(str, 3), lineno, colno);
colno += len;
line += 3;
return(tok);
}
else if (!canbeprime) {
/* Possibly a single quote delimited string */
int ind;
if (line[1] == '\'')
ind = 1;
else {
ind = 3;
while (line[ind]) {
if (line[ind] == '\'') {
if (line[ind + 1] && line[ind + 2] == '\'') {
ind = -1;
break;
}
else {
if (line[ind + 1] != '\'')
break;
ind++;
}
}
ind++;
}
}
if (ind > -1 && line[ind]) {
err = 1;
lexerr(lineno, colno, colno + ind,
"Expect double quotes to delimit a character string");
do
if (line[ind] == '\'')
line[ind] = '"';
while (ind--);
}
}
if (!err) { /* A prime */
int ind = namemap("'", 1);
tok = newtoken(ind, ind, lineno, colno);
colno++;
line++;
return(tok);
}
}
else if (*line == '"' || *line == '%') {
/* Scan a string literal */
int col = colno;
int oldindex = 0, newindex = -1;
char bracket = *line;
char nxtchr ;
char tmpstr[MAXLINE + 1];
int save_col; /* these are maintained to restore line */
char *save_line; /* in case of missing string bracket */
int save_newindex;
if ( (strchr(line+1, bracket)) == 0 ) {
char bracket_str[2];
*bracket_str = bracket;
*(bracket_str + 1) = '\0';
tok = newtoken(ERROR_SYM, namemap(bracket_str, 1),
lineno, colno);
line++;
colno++;
return(tok);
}
while (1) {
save_line = line + oldindex + 1;
save_col = col + 1;
save_newindex = newindex + 1;
do {
col++;
oldindex++;
newindex++;
nxtchr = line[oldindex] ;
tmpstr[newindex] = nxtchr ;
}
/* test separately for bracket for use of % as delimiter */
while (nxtchr != bracket && IS_STRING_CHAR(nxtchr));
if (line[oldindex] == bracket) {
if (line[oldindex + 1] == bracket) {
tmpstr[newindex] = bracket ;
oldindex++;
col++;
}
else {
tmpstr[newindex] = '\0';
tok = newtoken(STRING_SYM, namemap(tmpstr,
newindex), lineno, colno+1);
colno = col + 1;
line += oldindex + 1;
return(tok);
}
}
else if (line[oldindex] == '"') {
oldindex++;
lexerr(lineno, col, col,
"% delimited string contains \", being ignored");
}
else if (line[oldindex] == '\0') {
lexerr(lineno, colno, colno, "Missing string bracket");
/* restore values of line and colno to values prior to
* last set of string characters
*/
line = save_line;
colno = save_col;
/* insert a closing string bracket */
tmpstr[save_newindex] = bracket;
tmpstr[save_newindex + 1] = '\0';
tok = newtoken(STRING_SYM, namemap(tmpstr,
save_newindex + 1), lineno, colno);
return(tok);
}
/*
else if (isprint(line[oldindex]) || line[oldindex] == ' ')
tmpstr[newindex] = line[oldindex];
*/
else {
char msg[80];
sprintf(msg, "Invalid character %s in string deleted",
nonprintingmsg[line[oldindex++]]);
lexerr(lineno, col, col, msg);
col += (line[oldindex] == '\t') ? 7 - ((col-1)%8) : -1;
}
}
}
else if (ISDELIMITER(*line)) /* Scan a delimiter */
{
int len = 1, ind;
char str[3];
switch (*line) {
case '=' :
if (line[1] == '>')
len = 2;
break;
case '*' :
if (line[1] == '*')
len = 2;
break;
case ':' :
case '/' :
if (line[1] == '=')
len = 2;
break;
case '>' :
if (line[1] == '=' || line[1] == '>')
len = 2;
break;
case '<' :
if (line[1] == '=' || line[1] == '<' || line[1] == '>')
len = 2;
break;
case '.' :
if (line[1] == '.')
len = 2;
break;
case '!' :
*line = '|';
break;
case '[' : /* Change to a "(" */
lexerr(lineno, colno, colno,
"Bad character \"[\", replaced by \"(\".") ;
line[0] = '(' ;
break ;
case ']' : /* Change to a ")" */
/* Note that this case falls through to the next one */
lexerr(lineno, colno, colno,
"Bad character \"]\", replaced by \")\".") ;
line[0] = ')' ;
case ')' :
nextcanbeprime = 1;
break;
}
strncpy(str, line, len);
str[len] = '\0';
ind = namemap(str, len);
tok = newtoken(ind, ind, lineno, colno);
colno += len;
line += len;
return(tok);
}
else if (*line == '_') { /* An error- an underline _ */
lexerr(lineno, colno, colno, "Break character misplaced");
colno++;
line++;
}
else { /* An error- an unknown character */
char msg[80];
char ch[2];
*ch = *line;
ch[1] = '\0';
sprintf(msg, "Bad character in file ignored: %s",
(isprint(*line)) ? ch : nonprintingmsg[*line]);
lexerr(lineno, colno, colno, msg);
if (isprint(*line))
colno++;
line++;
}
}
if (getline() == EOF)
return(newtoken(EOFT_SYM, EOFT_SYM, lineno, colno));
}
}
