void
kerberos5_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen)
{
int i;
buf[buflen-1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
switch(data[3]) {
case KRB_REJECT: /* Rejected (reason might follow) */
strlcpy((char *)buf, " REJECT ", buflen);
goto common;
case KRB_ACCEPT: /* Accepted (name might follow) */
strlcpy((char *)buf, " ACCEPT ", buflen);
common:
BUMP(buf, buflen);
if (cnt <= 4)
break;
ADDC(buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC(buf, buflen, data[i]);
ADDC(buf, buflen, '"');
ADDC(buf, buflen, '\0');
break;
case KRB_AUTH: /* Authentication data follows */
strlcpy((char *)buf, " AUTH", buflen);
goto common2;
case KRB_RESPONSE:
strlcpy((char *)buf, " RESPONSE", buflen);
goto common2;
case KRB_FORWARD: /* Forwarded credentials follow */
strlcpy((char *)buf, " FORWARD", buflen);
goto common2;
case KRB_FORWARD_ACCEPT: /* Forwarded credentials accepted */
strlcpy((char *)buf, " FORWARD_ACCEPT", buflen);
goto common2;
case KRB_FORWARD_REJECT: /* Forwarded credentials rejected */
/* (reason might follow) */
strlcpy((char *)buf, " FORWARD_REJECT", buflen);
goto common2;
default:
snprintf(buf, buflen, " %d (unknown)", data[3]);
common2:
BUMP(buf, buflen);
for (i = 4; i < cnt; i++) {
snprintf(buf, buflen, " %d", data[i]);
BUMP(buf, buflen);
}
break;
}
}
void
kerberos4_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen)
{
char lbuf[32];
int i;
buf[buflen-1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
switch(data[3]) {
case KRB_REJECT: /* Rejected (reason might follow) */
strncpy((char *)buf, " REJECT ", buflen);
goto common;
case KRB_ACCEPT: /* Accepted (name might follow) */
strncpy((char *)buf, " ACCEPT ", buflen);
common:
BUMP(buf, buflen);
if (cnt <= 4)
break;
ADDC(buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC(buf, buflen, data[i]);
ADDC(buf, buflen, '"');
ADDC(buf, buflen, '\0');
break;
case KRB_AUTH: /* Authentication data follows */
strncpy((char *)buf, " AUTH", buflen);
goto common2;
case KRB_CHALLENGE:
strncpy((char *)buf, " CHALLENGE", buflen);
goto common2;
case KRB_RESPONSE:
strncpy((char *)buf, " RESPONSE", buflen);
goto common2;
default:
snprintf(lbuf, sizeof(lbuf), " %d (unknown)", data[3]);
strncpy((char *)buf, lbuf, buflen);
common2:
BUMP(buf, buflen);
for (i = 4; i < cnt; i++) {
snprintf(lbuf, sizeof(lbuf), " %d", data[i]);
strncpy((char *)buf, lbuf, buflen);
BUMP(buf, buflen);
}
break;
}
}
static __inline void AdjustOpacityLevels(void)
{
//playerState_t *ps = &cg.predictedPlayerState;
if ( (cg.predictedPlayerState.stats[STAT_HEALTH] < 1 || cg.deathcamTime) ||
cg.predictedPlayerState.zoomMode ||
cg.predictedPlayerState.pm_type == PM_INTERMISSION ||
cg.spectatorTime)
{
cg.jkg_HUDOpacity -= ((float)cg.frameDelta/200.0f);
} else {
cg.jkg_HUDOpacity += ((float)cg.frameDelta/200.0f);
}
CLAMP( cg.jkg_HUDOpacity, 0.0f, 1.0f );
if( cg.predictedPlayerState.weaponTime <= 0 )
{
cg.jkg_WHUDOpacity = 1.0f;
}
else
{
if( cg.predictedPlayerState.weaponstate == WEAPON_RAISING )
{
// pm->ps->weaponTime += 350;
int time = cg.predictedPlayerState.weaponTime-200;
BUMP( time, 0 );
cg.jkg_WHUDOpacity = 1.0f-((float)time/150);
}
else if( cg.predictedPlayerState.weaponstate == WEAPON_DROPPING )
{
// pm->ps->weaponTime += 300;
// Lerp it. Needs to be a 100 ms period where we can't see anything
int time = cg.predictedPlayerState.weaponTime-150;
BUMP( time, 0 );
cg.jkg_WHUDOpacity = (float)time/150;
}
else
{
// Not switching weapons I guess (must be firing or something). Just set it at 1.0f
cg.jkg_WHUDOpacity = 1.0f;
}
}
return;
}
void
video_pte_inserted( kernel_vars_t *kv, ulong lvptr, ulong *slot, ulong pte0, ulong pte1, ulong ea )
{
DECLARE_FB;
int i;
if( !fb )
return;
i = (lvptr - (ulong)fb->lv_base) >> 12;
if( i >= 0 && i < fb->nrec ) {
line_entry_t *p = &fb->line_table[i];
/* allow at most one video PTE to be mapped at any time */
if( p->slot && (p->slot != slot || p->pte0 != pte0) ) {
BUMP( video_pte_reinsert );
if( p->slot != slot )
p->slot[0] = 0;
__tlbie(p->ea);
p->dirty = 1;
}
p->slot = slot;
p->pte0 = pte0;
p->pte1 = pte1 & ~PTE1_C;
p->ea = ea;
} else {
printk("Warning: video_page outside range, %lx %p\n", lvptr, fb->lv_base );
}
}
/* return format is {startline,endline} pairs */
int
get_dirty_fb_lines( kernel_vars_t *kv, short *userbuf, int num_bytes )
{
DECLARE_FB;
int i, n, s, start;
line_entry_t *p;
s = num_bytes/sizeof(short[2]) - 1;
if( !fb || (uint)s <= 0 )
return -1;
p = fb->line_table;
for( start=-1, n=0, i=0; i<fb->nrec; i++, p++ ) {
if( p->slot ) {
if( p->slot[0] != p->pte0 ) {
/* evicted FB PTE */
p->slot = NULL;
p->dirty = 1;
__tlbie( p->ea );
} else if( p->slot[1] & MOL_BIT(24) ) { /* C-BIT */
p->dirty = 1;
__store_PTE( p->ea, p->slot, p->pte0, p->pte1 );
BUMP(fb_ptec_flush);
}
}
if( p->dirty && start < 0 )
start = p->y1;
else if( !p->dirty && start >= 0 ) {
__put_user( start, userbuf++ );
__put_user( p->y2, userbuf++ );
start = -1;
if( ++n >= s )
break;
}
p->dirty = 0;
}
if( start >= 0 ) {
__put_user( start, userbuf++ );
__put_user( fb->line_table[fb->nrec-1].y2, userbuf++ );
n++;
}
return n;
}
int
extoken_fn(register Expr_t* ex)
{
register int c;
register char* s;
register int q;
char* e;
if (ex->eof || ex->errors)
return 0;
again:
for (;;) switch (c = lex(ex))
{
case 0:
goto eof;
case '/':
switch (q = lex(ex))
{
case '*':
for (;;) switch (lex(ex))
{
case '\n':
BUMP (error_info.line);
continue;
case '*':
switch (lex(ex))
{
case 0:
goto eof;
case '\n':
BUMP (error_info.line);
break;
case '*':
exunlex(ex, '*');
break;
case '/':
goto again;
}
break;
}
break;
case '/':
while ((c = lex(ex)) != '\n')
if (!c)
goto eof;
break;
default:
goto opeq;
}
/*FALLTHROUGH*/
case '\n':
BUMP (error_info.line);
/*FALLTHROUGH*/
case ' ':
case '\t':
break;
case '(':
case '{':
case '[':
ex->input->nesting++;
return exlval.op = c;
case ')':
case '}':
case ']':
ex->input->nesting--;
return exlval.op = c;
case '+':
case '-':
if ((q = lex(ex)) == c)
return exlval.op = c == '+' ? INC : DEC;
goto opeq;
case '*':
case '%':
case '^':
q = lex(ex);
opeq:
exlval.op = c;
if (q == '=')
c = '=';
else if (q == '%' && c == '%')
{
if (ex->input->fp)
ex->more = (const char*)ex->input->fp;
else ex->more = ex->input->sp;
goto eof;
}
else exunlex(ex, q);
return c;
case '&':
case '|':
if ((q = lex(ex)) == '=')
{
exlval.op = c;
return '=';
}
if (q == c)
c = c == '&' ? AND : OR;
else exunlex(ex, q);
return exlval.op = c;
case '<':
case '>':
if ((q = lex(ex)) == c)
{
exlval.op = c = c == '<' ? LS : RS;
if ((q = lex(ex)) == '=')
c = '=';
else exunlex(ex, q);
return c;
}
goto relational;
case '=':
case '!':
q = lex(ex);
relational:
if (q == '=') switch (c)
{
case '<':
c = LE;
break;
case '>':
c = GE;
break;
case '=':
c = EQ;
break;
case '!':
c = NE;
break;
}
else exunlex(ex, q);
return exlval.op = c;
case '#':
if (!ex->linewrap && !(ex->disc->flags & EX_PURE))
{
s = ex->linep - 1;
while (s > ex->line && isspace(*(s - 1)))
s--;
if (s == ex->line)
{
switch (extoken_fn(ex))
{
case DYNAMIC:
case ID:
case NAME:
s = exlval.id->name;
break;
default:
s = "";
break;
}
if (streq(s, "include"))
{
if (extoken_fn(ex) != STRING)
exerror("#%s: string argument expected", s);
else if (!expush(ex, exlval.string, 1, NiL, NiL))
{
setcontext(ex);
goto again;
}
}
else exerror("unknown directive");
}
}
return exlval.op = c;
case '\'':
case '"':
q = c;
sfstrset(ex->tmp, 0);
ex->input->nesting++;
while ((c = lex(ex)) != q)
{
if (c == '\\')
{
sfputc(ex->tmp, c);
c = lex(ex);
}
if (!c)
{
exerror("unterminated %c string", q);
goto eof;
}
if (c == '\n')
{
BUMP (error_info.line);
}
sfputc(ex->tmp, c);
}
ex->input->nesting--;
s = sfstruse(ex->tmp);
if (q == '"' || (ex->disc->flags & EX_CHARSTRING))
{
if (!(exlval.string = vmstrdup(ex->vm, s)))
goto eof;
stresc(exlval.string);
return STRING;
}
exlval.integer = chrtoi(s);
return INTEGER;
case '.':
if (isdigit(c = lex(ex)))
{
sfstrset(ex->tmp, 0);
sfputc(ex->tmp, '0');
sfputc(ex->tmp, '.');
goto floating;
}
exunlex(ex, c);
return exlval.op = '.';
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
sfstrset(ex->tmp, 0);
sfputc(ex->tmp, c);
q = INTEGER;
if ((c = lex(ex)) == 'x' || c == 'X')
{
sfputc(ex->tmp, c);
for (;;)
{
switch (c = lex(ex))
{
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
sfputc(ex->tmp, c);
continue;
}
break;
}
}
else
{
while (isdigit(c))
{
sfputc(ex->tmp, c);
c = lex(ex);
}
if (c == '#')
{
sfputc(ex->tmp, c);
/* s = sfstruse(ex->tmp); */
/* b = strtol(s, NiL, 10); */
do
{
sfputc(ex->tmp, c);
} while (isalnum(c = lex(ex)));
}
else
{
if (c == '.')
{
floating:
q = FLOATING;
sfputc(ex->tmp, c);
while (isdigit(c = lex(ex)))
sfputc(ex->tmp, c);
}
if (c == 'e' || c == 'E')
{
q = FLOATING;
sfputc(ex->tmp, c);
if ((c = lex(ex)) == '-' || c == '+')
{
sfputc(ex->tmp, c);
c = lex(ex);
}
while (isdigit(c))
{
sfputc(ex->tmp, c);
c = lex(ex);
}
}
}
}
s = sfstruse(ex->tmp);
if (q == FLOATING)
exlval.floating = strtod(s, &e);
else
{
if (c == 'u' || c == 'U')
{
q = UNSIGNED;
c = lex(ex);
exlval.integer = strToL(s, &e);
}
else
exlval.integer = strToL(s, &e);
if (*e)
{
*--e = 1;
exlval.integer *= strton(e, &e, NiL, 0);
}
}
exunlex(ex, c);
if (*e || isalpha(c) || c == '_' || c == '$')
{
exerror("%s: invalid numeric constant", s);
goto eof;
}
return q;
default:
if (isalpha(c) || c == '_' || c == '$')
{
sfstrset(ex->tmp, 0);
sfputc(ex->tmp, c);
while (isalnum(c = lex(ex)) || c == '_' || c == '$')
sfputc(ex->tmp, c);
exunlex(ex, c);
s = sfstruse(ex->tmp);
if (!(exlval.id = (Exid_t*)dtmatch(ex->symbols, s)))
{
if (!(exlval.id = newof(0, Exid_t, 1, strlen(s) - EX_NAMELEN + 1)))
{
exerror("out of space");
goto eof;
}
strcpy(exlval.id->name, s);
exlval.id->lex = NAME;
dtinsert((ex->formals || !ex->symbols->view) ? ex->symbols : ex->symbols->view, exlval.id);
}
/*
* lexical analyzer state controlled by the grammar
*/
switch (exlval.id->lex)
{
case DECLARE:
if (exlval.id->index == CHAR)
{
/*
* `char*' === `string'
* the * must immediately follow char
*/
if (c == '*')
{
lex(ex);
exlval.id = id_string;
}
}
break;
case NAME:
/*
* action labels are disambiguated from ?:
* through the expr.nolabel grammar hook
* the : must immediately follow labels
*/
if (c == ':' && !expr.nolabel)
return LABEL;
break;
case PRAGMA:
/*
* user specific statement stripped and
* passed as string
*/
{
int b;
int n;
int pc = 0;
int po;
int t;
/*UNDENT...*/
sfstrset(ex->tmp, 0);
b = 1;
n = 0;
po = 0;
t = 0;
for (c = t = lex(ex);; c = lex(ex))
{
switch (c)
{
case 0:
goto eof;
case '/':
switch (q = lex(ex))
{
case '*':
for (;;)
{
switch (lex(ex))
{
case '\n':
BUMP (error_info.line);
continue;
case '*':
switch (lex(ex))
{
case 0:
goto eof;
case '\n':
BUMP (error_info.line);
continue;
case '*':
exunlex(ex, '*');
continue;
case '/':
break;
default:
continue;
}
break;
}
if (!b++)
goto eof;
sfputc(ex->tmp, ' ');
break;
}
break;
case '/':
while ((c = lex(ex)) != '\n')
if (!c)
goto eof;
BUMP (error_info.line);
b = 1;
sfputc(ex->tmp, '\n');
break;
default:
b = 0;
sfputc(ex->tmp, c);
sfputc(ex->tmp, q);
break;
}
continue;
case '\n':
BUMP (error_info.line);
b = 1;
sfputc(ex->tmp, '\n');
continue;
case ' ':
case '\t':
if (!b++)
goto eof;
sfputc(ex->tmp, ' ');
continue;
case '(':
case '{':
case '[':
b = 0;
if (!po)
{
switch (po = c)
{
case '(':
pc = ')';
break;
case '{':
pc = '}';
break;
case '[':
pc = ']';
break;
}
n++;
}
else if (c == po)
n++;
sfputc(ex->tmp, c);
continue;
case ')':
case '}':
case ']':
b = 0;
if (!po)
{
exunlex(ex, c);
break;
}
sfputc(ex->tmp, c);
if (c == pc && --n <= 0)
{
if (t == po)
break;
po = 0;
}
continue;
case ';':
b = 0;
if (!n)
break;
sfputc(ex->tmp, c);
continue;
case '\'':
case '"':
b = 0;
sfputc(ex->tmp, c);
ex->input->nesting++;
q = c;
while ((c = lex(ex)) != q)
{
if (c == '\\')
{
sfputc(ex->tmp, c);
c = lex(ex);
}
if (!c)
{
exerror("unterminated %c string", q);
goto eof;
}
if (c == '\n')
{
BUMP (error_info.line);
}
sfputc(ex->tmp, c);
}
ex->input->nesting--;
continue;
default:
b = 0;
sfputc(ex->tmp, c);
continue;
}
break;
}
(*ex->disc->reff)(ex, NiL, exlval.id, NiL, sfstruse(ex->tmp), 0, ex->disc);
/*..INDENT*/
}
goto again;
}
return exlval.id->lex;
}
return exlval.op = c;
}
eof:
ex->eof = 1;
return exlval.op = ';';
}
int
xworker_do_crawl (struct xwork *xwork, struct dirjob *job)
{
DIR *dirp = NULL;
int ret = -1;
int boff;
int plen;
struct dirent *result;
char dbuf[512];
char *path = NULL;
struct dirjob *cjob = NULL;
struct stat statbuf = {0,};
char gfid_path[4096] = {0,};
plen = strlen (job->dirname) + 256 + 2;
path = alloca (plen);
tdbg ("Entering: %s\n", job->dirname);
dirp = sys_opendir (job->dirname);
if (!dirp) {
terr ("opendir failed on %s (%s)\n", job->dirname,
strerror (errno));
goto out;
}
boff = sprintf (path, "%s/", job->dirname);
for (;;) {
ret = readdir_r (dirp, (struct dirent *)dbuf, &result);
if (ret) {
err ("readdir_r(%s): %s\n", job->dirname,
strerror (errno));
goto out;
}
if (!result) /* EOF */
break;
if (result->d_ino == 0)
continue;
if (skip_name (job->dirname, result->d_name))
continue;
/* It is sure that, children and grandchildren of .glusterfs
* are directories, just add them to global queue.
*/
if (skip_stat (job, result->d_name)) {
strncpy (path + boff, result->d_name, (plen-boff));
cjob = dirjob_new (path, job);
if (!cjob) {
err ("dirjob_new(%s): %s\n",
path, strerror (errno));
ret = -1;
goto out;
}
xwork_addcrawl (xwork, cjob);
continue;
}
strcpy (gfid_path, slavemnt);
strcat (gfid_path, "/.gfid/");
strcat (gfid_path, result->d_name);
ret = lstat (gfid_path, &statbuf);
if (ret && errno == ENOENT) {
out ("%s\n", result->d_name);
BUMP (skipped_gfids);
}
if (ret && errno != ENOENT) {
err ("stat on slave failed(%s): %s\n",
gfid_path, strerror (errno));
goto out;
}
}
ret = 0;
out:
if (dirp)
sys_closedir (dirp);
return ret;
}
