/*
* fsm_input - Input packet.
*/
void fsm_input(fsm *f, u_char *inpacket, int l) {
u_char *inp;
u_char code, id;
int len;
/*
* Parse header (code, id and length).
* If packet too short, drop it.
*/
inp = inpacket;
if (l < HEADERLEN) {
FSMDEBUG(("fsm_input(%x): Rcvd short header.", f->protocol));
return;
}
GETCHAR(code, inp);
GETCHAR(id, inp);
GETSHORT(len, inp);
if (len < HEADERLEN) {
FSMDEBUG(("fsm_input(%x): Rcvd illegal length.", f->protocol));
return;
}
if (len > l) {
FSMDEBUG(("fsm_input(%x): Rcvd short packet.", f->protocol));
return;
}
len -= HEADERLEN; /* subtract header length */
if( f->state == PPP_FSM_INITIAL || f->state == PPP_FSM_STARTING ){
FSMDEBUG(("fsm_input(%x): Rcvd packet in state %d.",
f->protocol, f->state));
return;
}
/*
* Action depends on code.
*/
switch (code) {
case CONFREQ:
fsm_rconfreq(f, id, inp, len);
break;
case CONFACK:
fsm_rconfack(f, id, inp, len);
break;
case CONFNAK:
case CONFREJ:
fsm_rconfnakrej(f, code, id, inp, len);
break;
case TERMREQ:
fsm_rtermreq(f, id, inp, len);
break;
case TERMACK:
fsm_rtermack(f);
break;
case CODEREJ:
fsm_rcoderej(f, inp, len);
break;
default:
if( !f->callbacks->extcode
|| !(*f->callbacks->extcode)(f, code, id, inp, len) )
fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
break;
}
}
static int
MatchText(char *t, int tlen, char *p, int plen,
pg_locale_t locale, bool locale_is_c)
{
/* Fast path for match-everything pattern */
if (plen == 1 && *p == '%')
return LIKE_TRUE;
/*
* In this loop, we advance by char when matching wildcards (and thus on
* recursive entry to this function we are properly char-synced). On other
* occasions it is safe to advance by byte, as the text and pattern will
* be in lockstep. This allows us to perform all comparisons between the
* text and pattern on a byte by byte basis, even for multi-byte
* encodings.
*/
while (tlen > 0 && plen > 0)
{
if (*p == '\\')
{
/* Next pattern byte must match literally, whatever it is */
NextByte(p, plen);
/* ... and there had better be one, per SQL standard */
if (plen <= 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
errmsg("LIKE pattern must not end with escape character")));
if (GETCHAR(*p) != GETCHAR(*t))
return LIKE_FALSE;
}
else if (*p == '%')
{
char firstpat;
/*
* % processing is essentially a search for a text position at
* which the remainder of the text matches the remainder of the
* pattern, using a recursive call to check each potential match.
*
* If there are wildcards immediately following the %, we can skip
* over them first, using the idea that any sequence of N _'s and
* one or more %'s is equivalent to N _'s and one % (ie, it will
* match any sequence of at least N text characters). In this way
* we will always run the recursive search loop using a pattern
* fragment that begins with a literal character-to-match, thereby
* not recursing more than we have to.
*/
NextByte(p, plen);
while (plen > 0)
{
if (*p == '%')
NextByte(p, plen);
else if (*p == '_')
{
/* If not enough text left to match the pattern, ABORT */
if (tlen <= 0)
return LIKE_ABORT;
NextChar(t, tlen);
NextByte(p, plen);
}
else
break; /* Reached a non-wildcard pattern char */
}
/*
* If we're at end of pattern, match: we have a trailing % which
* matches any remaining text string.
*/
if (plen <= 0)
return LIKE_TRUE;
/*
* Otherwise, scan for a text position at which we can match the
* rest of the pattern. The first remaining pattern char is known
* to be a regular or escaped literal character, so we can compare
* the first pattern byte to each text byte to avoid recursing
* more than we have to. This fact also guarantees that we don't
* have to consider a match to the zero-length substring at the
* end of the text.
*/
if (*p == '\\')
{
if (plen < 2)
ereport(ERROR,
(errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
errmsg("LIKE pattern must not end with escape character")));
firstpat = GETCHAR(p[1]);
}
else
firstpat = GETCHAR(*p);
while (tlen > 0)
{
if (GETCHAR(*t) == firstpat)
{
int matched = MatchText(t, tlen, p, plen,
locale, locale_is_c);
if (matched != LIKE_FALSE)
return matched; /* TRUE or ABORT */
}
NextChar(t, tlen);
}
/*
* End of text with no match, so no point in trying later places
* to start matching this pattern.
*/
return LIKE_ABORT;
}
else if (*p == '_')
{
/* _ matches any single character, and we know there is one */
NextChar(t, tlen);
NextByte(p, plen);
continue;
}
else if (GETCHAR(*p) != GETCHAR(*t))
{
/* non-wildcard pattern char fails to match text char */
return LIKE_FALSE;
}
/*
* Pattern and text match, so advance.
*
* It is safe to use NextByte instead of NextChar here, even for
* multi-byte character sets, because we are not following immediately
* after a wildcard character. If we are in the middle of a multibyte
* character, we must already have matched at least one byte of the
* character from both text and pattern; so we cannot get out-of-sync
* on character boundaries. And we know that no backend-legal
* encoding allows ASCII characters such as '%' to appear as non-first
* bytes of characters, so we won't mistakenly detect a new wildcard.
*/
NextByte(t, tlen);
NextByte(p, plen);
}
if (tlen > 0)
return LIKE_FALSE; /* end of pattern, but not of text */
/*
* End of text, but perhaps not of pattern. Match iff the remaining
* pattern can match a zero-length string, ie, it's zero or more %'s.
*/
while (plen > 0 && *p == '%')
NextByte(p, plen);
if (plen <= 0)
return LIKE_TRUE;
/*
* End of text with no match, so no point in trying later places to start
* matching this pattern.
*/
return LIKE_ABORT;
} /* MatchText() */
/*
* ipcp_nakci - Peer has sent a NAK for some of our CIs.
* This should not modify any state if the Nak is bad
* or if IPCP is in the LS_OPENED state.
*
* Returns:
* 0 - Nak was bad.
* 1 - Nak was good.
*/
static int
ipcp_nakci(fsm *f, u_char *p, int len)
{
ipcp_options *go = &ipcp_gotoptions[f->unit];
u_char cimaxslotindex, cicflag;
u_char citype, cilen, *next;
u_short cishort;
u32_t ciaddr1, ciaddr2, l, cidnsaddr;
ipcp_options no; /* options we've seen Naks for */
ipcp_options try; /* options to request next time */
BZERO(&no, sizeof(no));
try = *go;
/*
* Any Nak'd CIs must be in exactly the same order that we sent.
* Check packet length and CI length at each step.
* If we find any deviations, then this packet is bad.
*/
#define NAKCIADDR(opt, neg, old, code) \
if (go->neg && \
len >= (cilen = (old? CILEN_ADDRS: CILEN_ADDR)) && \
p[1] == cilen && \
p[0] == opt) { \
len -= cilen; \
INCPTR(2, p); \
GETLONG(l, p); \
ciaddr1 = htonl(l); \
if (old) { \
GETLONG(l, p); \
ciaddr2 = htonl(l); \
no.old_addrs = 1; \
} else { \
ciaddr2 = 0; \
} \
no.neg = 1; \
code \
}
#define NAKCIVJ(opt, neg, code) \
if (go->neg && \
((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \
len >= cilen && \
p[0] == opt) { \
len -= cilen; \
INCPTR(2, p); \
GETSHORT(cishort, p); \
no.neg = 1; \
code \
}
#define NAKCIDNS(opt, neg, code) \
if (go->neg && \
((cilen = p[1]) == CILEN_ADDR) && \
len >= cilen && \
p[0] == opt) { \
len -= cilen; \
INCPTR(2, p); \
GETLONG(l, p); \
cidnsaddr = htonl(l); \
no.neg = 1; \
code \
}
/*
* Accept the peer's idea of {our,his} address, if different
* from our idea, only if the accept_{local,remote} flag is set.
*/
NAKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr, go->old_addrs,
if (go->accept_local && ciaddr1) { /* Do we know our address? */
try.ouraddr = ciaddr1;
IPCPDEBUG((LOG_INFO, "local IP address %s\n",
inet_ntoa(ciaddr1)));
}
if (go->accept_remote && ciaddr2) { /* Does he know his? */
try.hisaddr = ciaddr2;
IPCPDEBUG((LOG_INFO, "remote IP address %s\n",
inet_ntoa(ciaddr2)));
}
);
/*
* Accept the peer's value of maxslotindex provided that it
* is less than what we asked for. Turn off slot-ID compression
* if the peer wants. Send old-style compress-type option if
* the peer wants.
*/
NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
if (cilen == CILEN_VJ) {
GETCHAR(cimaxslotindex, p);
GETCHAR(cicflag, p);
if (cishort == IPCP_VJ_COMP) {
try.old_vj = 0;
if (cimaxslotindex < go->maxslotindex) {
try.maxslotindex = cimaxslotindex;
}
if (!cicflag) {
try.cflag = 0;
}
} else {
try.neg_vj = 0;
/*
* upap_rauth - Receive Authenticate.
*/
static void upap_rauthreq(ppp_pcb *pcb, u_char *inp, int id, int len) {
u_char ruserlen, rpasswdlen;
char *ruser;
char *rpasswd;
char rhostname[256];
int retcode;
const char *msg;
int msglen;
if (pcb->upap.us_serverstate < UPAPSS_LISTEN)
return;
/*
* If we receive a duplicate authenticate-request, we are
* supposed to return the same status as for the first request.
*/
if (pcb->upap.us_serverstate == UPAPSS_OPEN) {
upap_sresp(pcb, UPAP_AUTHACK, id, "", 0); /* return auth-ack */
return;
}
if (pcb->upap.us_serverstate == UPAPSS_BADAUTH) {
upap_sresp(pcb, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */
return;
}
/*
* Parse user/passwd.
*/
if (len < 1) {
UPAPDEBUG(("pap_rauth: rcvd short packet."));
return;
}
GETCHAR(ruserlen, inp);
len -= sizeof (u_char) + ruserlen + sizeof (u_char);
if (len < 0) {
UPAPDEBUG(("pap_rauth: rcvd short packet."));
return;
}
ruser = (char *) inp;
INCPTR(ruserlen, inp);
GETCHAR(rpasswdlen, inp);
if (len < rpasswdlen) {
UPAPDEBUG(("pap_rauth: rcvd short packet."));
return;
}
rpasswd = (char *) inp;
/*
* Check the username and password given.
*/
retcode = UPAP_AUTHNAK;
if (auth_check_passwd(pcb, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen)) {
retcode = UPAP_AUTHACK;
}
BZERO(rpasswd, rpasswdlen);
#if 0 /* UNUSED */
/*
* Check remote number authorization. A plugin may have filled in
* the remote number or added an allowed number, and rather than
* return an authenticate failure, is leaving it for us to verify.
*/
if (retcode == UPAP_AUTHACK) {
if (!auth_number()) {
/* We do not want to leak info about the pap result. */
retcode = UPAP_AUTHNAK; /* XXX exit value will be "wrong" */
warn("calling number %q is not authorized", remote_number);
}
}
msglen = strlen(msg);
if (msglen > 255)
msglen = 255;
#endif /* UNUSED */
upap_sresp(pcb, retcode, id, msg, msglen);
/* Null terminate and clean remote name. */
ppp_slprintf(rhostname, sizeof(rhostname), "%.*v", ruserlen, ruser);
if (retcode == UPAP_AUTHACK) {
pcb->upap.us_serverstate = UPAPSS_OPEN;
ppp_notice("PAP peer authentication succeeded for %q", rhostname);
auth_peer_success(pcb, PPP_PAP, 0, ruser, ruserlen);
} else {
pcb->upap.us_serverstate = UPAPSS_BADAUTH;
ppp_warn("PAP peer authentication failed for %q", rhostname);
auth_peer_fail(pcb, PPP_PAP);
}
if (pcb->settings.pap_req_timeout > 0)
UNTIMEOUT(upap_reqtimeout, pcb);
}
/*
* upap_rauth - Receive Authenticate.
*/
static void
upap_rauthreq(upap_state *u, u_char *inp, u_char id, int len)
{
u_char ruserlen, rpasswdlen;
char *ruser, *rpasswd;
u_char retcode;
char *msg;
int msglen;
UPAPDEBUG(LOG_INFO, ("pap_rauth: Rcvd id %d.\n", id));
if (u->us_serverstate < UPAPSS_LISTEN) {
return;
}
/*
* If we receive a duplicate authenticate-request, we are
* supposed to return the same status as for the first request.
*/
if (u->us_serverstate == UPAPSS_OPEN) {
upap_sresp(u, UPAP_AUTHACK, id, "", 0); /* return auth-ack */
return;
}
if (u->us_serverstate == UPAPSS_BADAUTH) {
upap_sresp(u, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */
return;
}
/*
* Parse user/passwd.
*/
if (len < (int)sizeof (u_char)) {
UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));
return;
}
GETCHAR(ruserlen, inp);
len -= sizeof (u_char) + ruserlen + sizeof (u_char);
if (len < 0) {
UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));
return;
}
ruser = (char *) inp;
INCPTR(ruserlen, inp);
GETCHAR(rpasswdlen, inp);
if (len < rpasswdlen) {
UPAPDEBUG(LOG_INFO, ("pap_rauth: rcvd short packet.\n"));
return;
}
rpasswd = (char *) inp;
/*
* Check the username and password given.
*/
retcode = check_passwd(u->us_unit, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen);
/* lwip: currently retcode is always UPAP_AUTHACK */
BZERO(rpasswd, rpasswdlen);
upap_sresp(u, retcode, id, msg, msglen);
if (retcode == UPAP_AUTHACK) {
u->us_serverstate = UPAPSS_OPEN;
auth_peer_success(u->us_unit, PPP_PAP, ruser, ruserlen);
} else {
u->us_serverstate = UPAPSS_BADAUTH;
auth_peer_fail(u->us_unit, PPP_PAP);
}
if (u->us_reqtimeout > 0) {
UNTIMEOUT(upap_reqtimeout, u);
}
}
/* Rule (X1), (X2), (X3), (X4), (X5), (X6), (X7), (X8), (X9)
* returns the length of the string without explicit marks
*/
int doTypes(BLOCKTYPE line, unsigned char paragraphLevel, unsigned char* types,
unsigned char* levels, int count, int fX, int * v2l)
{
unsigned char tempType;
unsigned char currentEmbedding = paragraphLevel;
unsigned char currentOverride = ON;
int i, j;
unsigned char levelStack[MAX_STACK+2];
unsigned char overrideStack[MAX_STACK+2];
int stackTop = 0;
if(fX)
{
for( i=0, j=0; i<count; i++)
{
GETCHAR(line, j) = GETCHAR(line, i);
if(v2l)
{
v2l[j] = v2l[i];
}
tempType = GetType(GETCHAR(line, i));
switch(tempType)
{
case RLE:
if(stackTop < MAX_STACK)
{
levelStack[stackTop] = currentEmbedding;
overrideStack[stackTop] = currentOverride;
stackTop++;
currentEmbedding = leastGreaterOdd(currentEmbedding);
currentOverride = ON;
}
break;
case LRE:
if(stackTop < MAX_STACK)
{
levelStack[stackTop] = currentEmbedding;
overrideStack[stackTop] = currentOverride;
stackTop++;
currentEmbedding = leastGreaterEven(currentEmbedding);
currentOverride = ON;
}
break;
case RLO:
if(stackTop < MAX_STACK)
{
levelStack[stackTop] = currentEmbedding;
overrideStack[stackTop] = currentOverride;
stackTop++;
currentEmbedding = leastGreaterOdd(currentEmbedding);
currentOverride = R;
}
break;
case LRO:
if(stackTop <= MAX_STACK)
{
levelStack[stackTop] = currentEmbedding;
overrideStack[stackTop] = currentOverride;
stackTop++;
currentEmbedding = leastGreaterEven(currentEmbedding);
currentOverride = L;
}
break;
case PDF:
if(stackTop > 0)
{
currentEmbedding = levelStack[stackTop-1];
currentOverride = overrideStack[stackTop-1];
stackTop--;
}
break;
/* Whitespace is treated as neutral for now */
case WS:
case B:
case S:
levels[j] = currentEmbedding;
tempType = ON;
if(currentOverride != ON)
tempType = currentOverride;
types[j] = tempType;
j++;
break;
default:
levels[j] = currentEmbedding;
if(currentOverride != ON)
tempType = currentOverride;
types[j] = tempType;
j++;
break;
}
}
}else
{
j = count;
for( i=0; i<count; i++)
{
tempType = GetType(GETCHAR(line, i));
switch(tempType)
{
case WS:
case B:
case S:
levels[i] = currentEmbedding;
tempType = ON;
if(currentOverride != ON)
tempType = currentOverride;
break;
default:
levels[i] = currentEmbedding;
if(currentOverride != ON)
tempType = currentOverride;
break;
}
types[i] = tempType;
}
}
return j;
}
static int rcp_get_token(struct rcp_parser *parser)
{
char tok = ' ';
char *ptr;
size_t ptr_len;
while (isspace(tok))
tok = GETCHAR(parser);
ptr = parser->rcpp_str_buffer;
/* tok can't be ipv4 */
if (isalnum(tok)) {
int xdigit, digit, dot_number;
RT_ZERO(parser->rcpp_str_buffer);
dot_number = 0;
xdigit = 1;
digit = 1;
do {
*ptr++ = tok;
tok = GETCHAR(parser);
if (!isalnum(tok) && tok != ':' && tok != '.' && tok != '-' && tok != '_')
break;
/**
* if before ':' there were only [0-9][a-f][A-F],
* then it can't be option.
*/
xdigit &= (isxdigit(tok) || (tok == ':'));
/**
* We want hint to differ ipv4 and network name.
*/
digit &= (isdigit(tok) || (tok == '.'));
if (tok == ':')
{
if (xdigit == 1)
{
int port = 0;
do
{
*ptr++ = tok;
tok = GETCHAR(parser);
if (tok == '.')
port++;
} while(PARSER_STOP(tok, parser, ptr) && (tok == ':' || tok == '.' || isxdigit(tok)));
PARSER_BUFFER_EXCEEDED(parser, ptr);
if (port == 0)
return tok_ipv6;
else if (port == 1)
return tok_ipv6_port;
else
{
/* eats rest of the token */
do
{
*ptr++ = tok;
tok = GETCHAR(parser);
} while( PARSER_STOP(tok, parser, ptr)
&& (isalnum(tok) || tok == '.' || tok == '_' || tok == '-'));
PARSER_BUFFER_EXCEEDED(parser, ptr);
return tok_string;
}
}
else {
/* XXX: need further experiments */
return tok_option; /* option with value */
}
}
if (tok == '.')
{
do {
if (tok == '.') dot_number++;
*ptr++ = tok;
digit &= (isdigit(tok) || (tok == '.'));
tok = GETCHAR(parser);
} while( PARSER_STOP(tok, parser, ptr)
&& (isalnum(tok) || tok == '.' || tok == '_' || tok == '-'));
PARSER_BUFFER_EXCEEDED(parser, ptr);
if (dot_number == 3 && digit)
return tok_ipv4;
else if (dot_number == 4 && digit)
return tok_ipv4_port;
else
return tok_string;
}
} while( PARSER_STOP(tok, parser, ptr)
&& (isalnum(tok) || tok == ':' || tok == '.' || tok == '-' || tok == '_'));
PARSER_BUFFER_EXCEEDED(parser, ptr);
if (digit || xdigit)
return tok_number;
if (RTStrCmp(parser->rcpp_str_buffer, "nameserver") == 0)
return tok_nameserver;
if (RTStrCmp(parser->rcpp_str_buffer, "port") == 0)
return tok_port;
if (RTStrCmp(parser->rcpp_str_buffer, "domain") == 0)
return tok_domain;
if (RTStrCmp(parser->rcpp_str_buffer, "search") == 0)
return tok_search;
if (RTStrCmp(parser->rcpp_str_buffer, "search_order") == 0)
return tok_search_order;
if (RTStrCmp(parser->rcpp_str_buffer, "sortlist") == 0)
return tok_sortlist;
if (RTStrCmp(parser->rcpp_str_buffer, "timeout") == 0)
return tok_timeout;
if (RTStrCmp(parser->rcpp_str_buffer, "options") == 0)
return tok_options;
return tok_string;
}
if (tok == EOF) return tok_eof;
if (tok == '#')
{
do{
tok = GETCHAR(parser);
} while (tok != EOF && tok != '\r' && tok != '\n');
if (tok == EOF) return tok_eof;
return tok_comment;
}
return tok;
}
/* SM2 */
static int sm_rx_waitseq(s_rx_emsidat *d)
{
int rc, pos = 0;
timer_set(&d->sync_timer, 20);
while(1)
{
if( timer_expired(d->mast_timer) )
{
DEB((D_HSHAKE, "sm_rx_waitseq: master timer expired"));
log("master timer expired");
return SME;
}
if( timer_expired(d->sync_timer) )
{
DEB((D_HSHAKE, "sm_rx_waitseq: sync timer expired"));
return SM1;
}
if( (rc = GETCHAR(1)) < 0 )
{
if( rc != TTY_TIMEOUT )
{
DEB((D_HSHAKE, "sm_rx_waitseq: got ERROR/HANGUP"));
return SME;
}
}
else if( rc == XON || rc == XOFF )
{
/* Do nothing. Drop them down */
}
else if( rc == '*' )
{
memset(d->buf, '\0', sizeof(d->buf));
pos = 0;
d->emsi_seq = 1;
}
else if( d->emsi_seq && rc > ' ' && rc < '~' )
{
if( pos < sizeof(d->buf)-1 )
{
d->buf[pos++] = rc;
d->buf[pos ] = '\0';
}
if( pos == sizeof(d->buf)-1 )
{
DEB((D_HSHAKE, "sm_rx_waitseq: emsi buffer full \"%s\"", d->buf));
d->emsi_seq = 0;
if( d->caller && !strncasecmp(d->buf, "EMSI_ACKA490", 12) )
{
/* Do nothing. Drop it down. */
}
else if( !strncasecmp(d->buf, "EMSI_HBTEAEE", 12) )
{
/*
* Remote wants some time to think
*/
return SM2;
}
else if( !strncasecmp(d->buf, "EMSI_DAT", 8) )
{
/*
* Start receiving emsi data packet
*/
return SM3;
}
#ifndef BUGGY_EMSI
else if( !strncasecmp(d->buf, "EMSI_INQC816", 12) )
{
return SM1;
}
#endif /*BUGGY_EMSI*/
else
{
DEB((D_HSHAKE, "got unexpected emsi sequence: \"%s\"",
string_printable(d->buf)));
log("got unexpected emsi sequence \"%s\"",
string_printable(d->buf));
}
}
}
else if( d->emsi_seq )
{
d->emsi_seq = 0;
DEB((D_HSHAKE, "sm_rx_waitseq: bad character 0x%02x in \"%s\"",
rc, string_printable(d->buf)));
}
}
return SME;
}
/* SM3 */
static int sm_rx_getdat(s_rx_emsidat *d)
{
int rc = 0;
int pos = 0;
int emsi_len = 0;
short unsigned ourcrc;
short unsigned remcrc;
char *emsi_dat = NULL;
if( d->tries_recv++ )
log("emsi data receive - retry %d", d->tries_recv);
/*
* At this point, there is a EMSI_DATXXXX packet in
* the buffer, there XXXX is the hex length of emsi
* data packet
*/
if( strspn(d->buf+8, "0123456789abcdefABCDEF") != 4 )
return SM1;
if( sscanf(d->buf+8, "%04x", &emsi_len) != 1 )
return SM1;
/*
* Don't receive emsi packet's longer our "limit"
*/
if( emsi_len > EMSI_MAXDAT )
{
CLEARIN();
log("emsi data packet too long %db (maximum %db allowed)",
emsi_len, EMSI_MAXDAT);
return SM1;
}
/* Increase packet's length on CRC length */
emsi_len += 16;
emsi_dat = (char*)xmalloc(emsi_len + 1);
strncpy(emsi_dat, d->buf, 12);
pos = 12;
while( pos < emsi_len )
{
if( timer_expired(d->mast_timer) )
break;
if( (rc = GETCHAR(1)) < 0 )
{
if( rc != TTY_TIMEOUT )
break;
}
else
{
emsi_dat[pos++] = (unsigned char)rc;
emsi_dat[pos ] = '\0';
}
}
if( pos != emsi_len )
{
/* Fatal error occured */
DEB((D_HSHAKE, "sm_rx_getdat: can't get emsi_dat packet"));
DEB((D_HSHAKE, "sm_rx_getdat: buffer: \"%s\"",
string_printable(emsi_dat)));
free(emsi_dat);
return SME;
}
DEB((D_HSHAKE, "sm_rx_getdat: got \"%s\"",
string_printable(emsi_dat)));
/*
* Get CRC given by remote
*/
if( sscanf(emsi_dat + emsi_len - 4 , "%04hX", &remcrc) != 1 )
{
log("bad emsi data packet (can't get CRC16)");
free(emsi_dat);
return(SM1);
}
/*
* Calculate our own crc of the data packet
*/
ourcrc = getcrc16xmodem(emsi_dat, emsi_len-4);
/*
* Compare our and remote CRCs
*/
if( ourcrc != remcrc )
{
DEB((D_HSHAKE, "sm_rx_getdat: our = %hX, remote = %hX", ourcrc, remcrc));
log("got emsi data packet with bad CRC");
free(emsi_dat);
return SM1;
}
/*
* Parse received emsi data packet. All obtained
* information will be stored in d->remote_emsi
*/
rc = emsi_parsedat(emsi_dat+12, d->remote_emsi);
free(emsi_dat);
if( rc )
{
log("received invalid emsi data packet");
return SM1;
}
/* Send acknowlegment */
if( PUTSTR("**EMSI_ACKA490\r**EMSI_ACKA490\r") < 0 )
return SME;
if( FLUSHOUT() < 0 )
return SME;
return SM0;
}
int console_readkey(void)
{
unsigned char ch;
int num;
GETCHAR(ch);
switch (ch) {
case VKEY_ESC:
GETCHAR(ch);
switch (ch) {
case 'O':
GETCHAR(ch);
switch (ch) {
case 'P':
return VKEY_F1;
case 'Q':
return VKEY_F2;
case 'R':
return VKEY_F3;
case 'S':
return VKEY_F4;
}
return (int)ch;
case '[':
GETCHAR(ch);
if ((ch >= '0') && (ch <= '9')) {
console_readnum(&num,&ch);
if (ch == '~') {
switch (num) {
case 2:
return VKEY_HOME;
case 3:
return VKEY_PGUP;
case 5:
if (console_mode == XTERM) return VKEY_PGUP;
return VKEY_END;
case 6:
if (console_mode == XTERM) return VKEY_PGDN;
return VKEY_PGDN;
case 11:
return VKEY_F1;
case 12:
return VKEY_F2;
case 13:
return VKEY_F3;
case 14:
return VKEY_F4;
case 15:
return VKEY_F5;
case 17:
return VKEY_F6;
case 18:
return VKEY_F7;
case 19:
return VKEY_F8;
case 20:
return VKEY_F9;
case 21:
return VKEY_F10;
case 23:
return VKEY_F11;
case 24:
return VKEY_F12;
}
return (int)ch;
}
}
else {
switch (ch) {
case 'A':
return VKEY_UP;
case 'B':
return VKEY_DOWN;
case 'C':
return VKEY_RIGHT;
case 'D':
return VKEY_LEFT;
case 'F':
return VKEY_HOME;
case 'H':
return VKEY_END;
default:
return (int) ch;
}
}
default:
return (int)ch;
}
default:
return (int) ch;
}
}
/* SM2 */
static int sm_tx_waitseq(s_tx_emsidat *d)
{
int rc, pos = 0;
timer_set(&d->sync_timer, (d->tries > 1) ? 20 : 10);
while(1)
{
if( timer_expired(d->mast_timer) )
{
DEB((D_HSHAKE, "sm_tx_waitseq: master timer expired"));
log("master timer expired");
return(SME);
}
if( timer_expired(d->sync_timer) )
{
DEB((D_HSHAKE, "sm_tx_waitseq: sync timer expired"));
return(SM1);
}
if( (rc = GETCHAR(1)) < 0 )
{
if( rc != TTY_TIMEOUT )
{
DEB((D_HSHAKE, "sm_rx_waitseq: got ERROR/HANGUP"));
return SME;
}
}
else if( rc == XON || rc == XOFF )
{
/* Do nothing. Drop them down */
}
else if( rc == '*' )
{
memset(d->buf, '\0', sizeof(d->buf));
pos = 0;
d->emsi_seq = 1;
}
else if( d->emsi_seq && rc > ' ' && rc < '~' )
{
if( pos < sizeof(d->buf)-1 )
{
d->buf[pos++] = rc;
d->buf[pos ] = '\0';
}
if( pos == (sizeof(d->buf) - 1) )
{
DEB((D_HSHAKE, "sm_tx_waitseq: emsi buffer full \"%s\"", d->buf));
d->emsi_seq = 0;
if( !strncasecmp(d->buf, "EMSI_REQA77E", 12) )
{
/* Do nothing. Drop it down */
}
else if( !strncasecmp(d->buf, "EMSI_ACKA490", 12) )
{
/*
* Remote acknowleged our
* emsi data packet. exit.
*/
return SM0;
}
else if( !strncasecmp(d->buf, "EMSI_NAKEEC3", 12) )
{
/*
* Remote failed on our emsi data
* packet. Resend EMSI_DAT only after
* first EMSI_NAK
*/
DEB((D_HSHAKE, "sm_tx_waitseq: got NAK"));
if( !d->nakcount++ )
return SM1;
}
else if( !strncasecmp(d->buf, "EMSI_INQC816", 12) )
{
/*
* Do nothing. Just update sync timer
*/
return SM2;
}
else if( !strncasecmp(d->buf, "EMSI_DAT", 8) )
{
/*
* 1) We are calling system
* We got an echo of our sequence,
* possible they don't know about
* FIDO. yet :) Resend EMSI_INQ
* again.
* 2) We are asnwering system
* Think where is a stupid mailer
* that didn't seen our EMSI_ACK,
* so send it again in hope to the
* best
*/
DEB((D_HSHAKE, "sm_tx_waitseq: got echo \"%s\"",
string_printable(d->buf)));
if( d->caller )
{
/* Wait for a login prompt */
sleep(2);
if( PUTSTR("**EMSI_INQC816\r") < 0
|| FLUSHOUT() < 0 )
return SME;
/* Wait for a password prompt */
sleep(2);
if( PUTSTR("**EMSI_INQC816\r") < 0
|| FLUSHOUT() < 0 )
return SME;
return SM1;
}
else
{
/* Send acknowlegment */
if( PUTSTR("**EMSI_ACKA490\r**EMSI_ACKA490\r") < 0 )
return SME;
if( FLUSHOUT() < 0 )
return SME;
}
}
else
{
DEB((D_HSHAKE, "got unexpected emsi sequence: \"%s\"",
string_printable(d->buf)));
log("got unexpected emsi sequence \"%s\"",
string_printable(d->buf));
}
}
}
else if( d->emsi_seq )
{
d->emsi_seq = 0;
DEB((D_HSHAKE, "sm_tx_waitseq: bad character 0x%02x in \"%s\"",
rc, string_printable(d->buf)));
}
}
return SME;
}
/** Called when a CHAP packet is received. */
void
chap_input(chap *_this, u_char *pktp, int len)
{
int code, id, length, lval, lname, authok;
u_char *pktp1, *val, namebuf[MAX_USERNAME_LENGTH];
char *name;
if (_this->state == CHAP_STATE_STOPPED ||
_this->state == CHAP_STATE_INITIAL) {
chap_log(_this, LOG_INFO, "Received chap packet. But chap is "
"not started");
return;
}
CHAP_ASSERT(_this != NULL);
if (len < 4) {
chap_log(_this, LOG_ERR, "%s: Received broken packet.",
__func__);
return;
}
pktp1 = pktp;
GETCHAR(code, pktp1);
GETCHAR(id, pktp1);
GETSHORT(length, pktp1);
if (len < length || len < 5) {
chap_log(_this, LOG_ERR, "%s: Received broken packet.",
__func__);
return;
}
if (code != CHAP_RESPONSE) {
chap_log(_this, LOG_ERR, "Received unknown code=%d", code);
return;
}
/* Create a chap response */
if (id != _this->challid) {
chap_log(_this, LOG_ERR,
"Received challenge response has unknown id.");
return;
}
if (_this->state == CHAP_STATE_AUTHENTICATING)
return;
authok = 0;
UNTIMEOUT(chap_start, _this);
/* pick the username */
GETCHAR(lval, pktp1);
val = pktp1;
pktp1 += lval;
if (lval > length) {
chap_log(_this, LOG_ERR,
"Received challenge response has invalid Value-Size "
"field. %d", lval);
return;
}
name = pktp1;
lname = len - (pktp1 - pktp);
if (lname <= 0 || sizeof(namebuf) <= lname + 1) {
chap_log(_this, LOG_ERR,
"Received challenge response has invalid Name "
"field.");
return;
}
memcpy(namebuf, name, lname);
namebuf[lname] = '\0';
name = namebuf;
if (_this->state == CHAP_STATE_SENT_RESPONSE) {
if (strcmp(_this->name, name) != 0) {
/*
* The peer requests us to resend, but the username
* has been changed.
*/
chap_log(_this, LOG_ERR,
"Received AuthReq is not same as before. "
"%s != %s", name, _this->name);
return;
}
} else if (_this->state != CHAP_STATE_SENT_CHALLENGE) {
chap_log(_this, LOG_ERR,
"Received AuthReq in illegal state. username=%s", name);
return;
}
_this->state = CHAP_STATE_AUTHENTICATING;
strlcpy(_this->name, name, sizeof(_this->name));
chap_authenticate(_this, val, lval);
}
int main(void) {
/* Init board hardware. */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
for(uint8_t i = 0; i < NUM_LEDS; i++) {
leds[i].r = 0;
leds[i].g = 0;
leds[i].b = 0;
}
struct FLEXIO_WS2812_LED led;
led.r = 0;
led.g = 0;
led.b = 0;
/* Init and enable FlexIO */
CLOCK_EnableClock(kCLOCK_Flexio0);
flexio_config_t user_config = {
.enableFlexio = true,
.enableInDoze = false,
.enableInDebug = false,
.enableFastAccess = false
};
FLEXIO_Init(FLEXIO0, &user_config);
FLEXIO_Enable(FLEXIO0, true);
FLEXIO_WS2812_Init();
/* Init GPIOs */
gpio_pin_config_t config =
{
kGPIO_DigitalOutput,
0,
};
GPIO_PinInit(GPIOA, 5U, &config);
GPIO_WritePinOutput(GPIOA, 5U, 0U);
GPIO_PinInit(GPIOA, 13U, &config);
GPIO_WritePinOutput(GPIOA, 13U, 0U);
GPIO_PinInit(GPIOA, 12U, &config);
GPIO_WritePinOutput(GPIOA, 12U, 0U);
GPIO_PinInit(GPIOA, 17U, &config);
GPIO_WritePinOutput(GPIOA, 17U, 0U);
GPIO_PinInit(GPIOA, 14U, &config);
GPIO_WritePinOutput(GPIOA, 14U, 0U);
GPIO_PinInit(GPIOC, 7U, &config);
GPIO_WritePinOutput(GPIOC, 7U, 0U);
GPIO_PinInit(GPIOA, 16U, &config);
GPIO_WritePinOutput(GPIOA, 16U, 0U);
GPIO_PinInit(GPIOA, 15U, &config);
GPIO_WritePinOutput(GPIOA, 15U, 0U);
while(1) {
/* Read serial char */
char ch = GETCHAR();
switch(ch) {
/* All LEDs red */
case 'r':
led.r = 255;
led.g = 0;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs green */
case 'g':
led.r = 0;
led.g = 255;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs red */
case 'b':
led.r = 0;
led.g = 0;
led.b = 255;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* All LEDs off */
case 'o':
led.r = 0;
led.g = 0;
led.b = 0;
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_Update(&led);
FLEXIO_WS2812_TransmitBuffer();
break;
/* Serial test */
case 's':
PRINTF("Serial test\r\n");
break;
/* Start measurement */
case 'p':
updaterange();
PRINTF("%d,%d,%d,%d,%d,%d,%d,%d\r\n", range[0], range[1], range[2], range[3], range[4], range[5], range[6], range[7]);
break;
}
}
}
static int tcp_rblk(char *buf, int *len)
{
int c;
*len = 0;
/*
* Wait up to 3 minutes for the header
*/
c = GETCHAR(180);
if (tty_status)
goto to;
if (c != TCP_BLKSTRT) {
WriteError("tcp_rblk: got %d instead of block header", c);
return c;
}
/*
* Get block type
*/
c = GETCHAR(120);
if (tty_status)
goto to;
rx_type = c;
if (c != TCP_CMD && c != TCP_DATA) {
WriteError("tcp_rblk: got %d character instead of DATA/CMD", c);
return c;
}
/*
* Get block length
*/
c = GETCHAR(120);
if (tty_status)
goto to;
*len = c << 8;
c = GETCHAR(120);
if (tty_status)
goto to;
*len += c;
if (*len > TCP_BLKSIZE) {
WriteError("TCP: remote sends too large block: %d bytes", len);
return 1;
}
/*
* Get actual data block
*/
if (*len != 0) {
GET(buf, *len, 120);
if (tty_status)
goto to;
} else {
WriteError("TCP: remote sends empty frame");
}
/*
* Get block trailer
*/
c = GETCHAR(120);
if (tty_status)
goto to;
if (c != TCP_BLKEND) {
WriteError("TCP: got %d instead of block trailer", c);
return c;
}
if (rx_type == TCP_CMD) {
buf[*len] = '\0';
Syslog('a', "tcp_rblk: cmd: %s", buf);
} else
Syslog('a', "tcp_rblk: data: %d bytes", *len);
to:
if (tty_status)
WriteError("TCP: receive error: %s", ttystat[tty_status]);
return tty_status;
}
/*
* The Main Bidi Function, and the only function that should
* be used by the outside world.
*
* line: a buffer of size count containing text to apply
* the Bidirectional algorithm to.
*/
int doBidi(BLOCKTYPE line, int count, int applyShape, int reorderCombining, int * v2l, int * l2v)
{
unsigned char* types;
unsigned char* levels;
unsigned char paragraphLevel;
unsigned char tempType, tempTypeSec;
int i, j, imax, fX, fAL, fET, fNSM, tempInt;
CHARTYPE* shapeTo;
if (v2l)
{
for(i=0; i<count; i++)
{
v2l[i] = i;
l2v[i] = i;
}
}
fX = fAL = fET = fNSM = 0;
for(i=0; i<count; i++)
{
switch(GetType(line[i]))
{
case AL:
case R:
fAL = 1;
break;
case LRE:
case LRO:
case RLE:
case RLO:
case PDF:
case BN:
fX = 1;
break;
case ET:
fET = 1;
break;
case NSM:
fNSM = 1;
break;
}
}
if(!fAL && !fX)
return 0;
/* Initialize types, levels */
types = (unsigned char*)malloc(sizeof(unsigned char) * count);
levels = (unsigned char*)malloc(sizeof(unsigned char) * count);
if(applyShape)
shapeTo = (CHARTYPE*)malloc(sizeof(CHARTYPE) * count);
/* Rule (P1) NOT IMPLEMENTED
* P1. Split the text into separate paragraphs. A paragraph separator is
* kept with the previous paragraph. Within each paragraph, apply all the
* other rules of this algorithm.
*/
/* Rule (P2), (P3)
* P2. In each paragraph, find the first character of type L, AL, or R.
* P3. If a character is found in P2 and it is of type AL or R, then set
* the paragraph embedding level to one; otherwise, set it to zero.
*/
paragraphLevel = GetParagraphLevel(line, count);
/* Rule (X1), (X2), (X3), (X4), (X5), (X6), (X7), (X8), (X9)
* X1. Begin by setting the current embedding level to the paragraph
* embedding level. Set the directional override status to neutral.
* X2. With each RLE, compute the least greater odd embedding level.
* X3. With each LRE, compute the least greater even embedding level.
* X4. With each RLO, compute the least greater odd embedding level.
* X5. With each LRO, compute the least greater even embedding level.
* X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
* a. Set the level of the current character to the current
* embedding level.
* b. Whenever the directional override status is not neutral,
* reset the current character type to the directional
* override status.
* X7. With each PDF, determine the matching embedding or override code.
* If there was a valid matching code, restore (pop) the last
* remembered (pushed) embedding level and directional override.
* X8. All explicit directional embeddings and overrides are completely
* terminated at the end of each paragraph. Paragraph separators are not
* included in the embedding. (Useless here) NOT IMPLEMENTED
* X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
* Here, they're converted to BN.
*/
count = doTypes(line, paragraphLevel, types, levels, count, fX, v2l);
GETCHAR(line, count) = 0;
/* Rule (W1)
* W1. Examine each non-spacing mark (NSM) in the level run, and change
* the type of the NSM to the type of the previous character. If the NSM
* is at the start of the level run, it will get the type of sor.
*/
if(fNSM)
{
if(types[0] == NSM)
types[0] = paragraphLevel;
for(i=1; i<count; i++)
{
if(types[i] == NSM)
types[i] = types[i-1];
/* Is this a safe assumption?
* I assumed the previous, IS a character.
*/
}
}
/* Rule (W2)
* W2. Search backwards from each instance of a European number until the
* first strong type (R, L, AL, or sor) is found. If an AL is found,
* change the type of the European number to Arabic number.
*/
for(i=0; i<count; i++)
{
if(types[i] == EN)
{
tempType = levels[i];
j=i;
while(--j >= 0 && levels[j] == tempType)
{
if(types[j] == AL)
{
types[i] = AN;
break;
}
else if(types[j] == R || types[j] == L)
{
break;
}
}
}
}
/* Rule (W3)
* W3. Change all ALs to R.
*
* Optimization: on Rule Xn, we might set a flag on AL type
* to prevent this loop in L R lines only...
*/
doALtoR(types, count);
/* Rule (W4)
* W4. A single European separator between two European numbers changes
* to a European number. A single common separator between two numbers
* of the same type changes to that type.
*/
for( i=0; i<(count-1); i++)
{
if(types[i] == ES)
{
if(types[i-1] == EN && types[i+1] == EN)
types[i] = EN;
}else if(types[i] == CS)
{
if(types[i-1] == EN && types[i+1] == EN)
types[i] = EN;
else if(types[i-1] == AN && types[i+1] == AN)
types[i] = AN;
}
}
/* Rule (W5)
* W5. A sequence of European terminators adjacent to European numbers
* changes to all European numbers.
*
* Optimization: lots here... else ifs need rearrangement
*/
if(fET)
{
for(i=0; i<count; i++)
{
if(types[i] == ET)
{
if(types[i-1] == EN)
{
types[i] = EN;
continue;
}else if(types[i+1] == EN)
{
types[i] = EN;
continue;
}else if(types[i+1] == ET)
{
j=i;
while(j <count && types[j] == ET)
{
j++;
}
if(types[j] == EN)
types[i] = EN;
}
}
}
}
/* Rule (W6)
* W6. Otherwise, separators and terminators change to Other Neutral:
*/
for(i=0; i<count; i++)
{
switch(types[i])
{
case ES:
case ET:
case CS:
types[i] = ON;
break;
}
}
/* Rule (W7)
* W7. Search backwards from each instance of a European number until
* the first strong type (R, L, or sor) is found. If an L is found,
* then change the type of the European number to L.
*/
for(i=0; i<count; i++)
{
if(types[i] == EN)
{
tempType = levels[i];
j=i;
while(--j >= 0 && levels[j] == tempType)
{
if(types[j] == L)
{
types[i] = L;
break;
}
else if(types[j] == R || types[j] == AL)
{
break;
}
}
}
}
/* Rule (N1)
* N1. A sequence of neutrals takes the direction of the surrounding
* strong text if the text on both sides has the same direction. European
* and Arabic numbers are treated as though they were R.
*/
tempType = paragraphLevel;
for(i=0; i<count; i++)
{
if(types[i] == ON)
{
if(types[i-1] == R || types[i-1] == EN || types[i-1] == AN)
tempType = R;
else
tempType = L;
j=i;
while(j < count)
{
tempTypeSec = types[j];
if(tempTypeSec == ON)
j++;
else
break;
}
if(j == count)
tempTypeSec = odd(paragraphLevel) ? R : L;
if(((tempTypeSec == L || tempTypeSec == LRE) && (tempType == L)) ||
(((tempTypeSec == R) || (tempTypeSec == EN) || (tempTypeSec == AN)) && (tempType == R)))
{
while(i<j)
{
types[i++] = tempType;
}
}else
i = j;
}
}
/* Rule (N2)
* N2. Any remaining neutrals take the embedding direction.
*/
for(i=0; i<count; i++)
{
if(types[i] == ON)
{
if((levels[i] % 2) == 0)
types[i] = L;
else
types[i] = R;
}
}
/* Rule (I1)
* I1. For all characters with an even (left-to-right) embedding
* direction, those of type R go up one level and those of type AN or
* EN go up two levels.
*/
for(i=0; i<count; i++)
{
if((levels[i] % 2) == 0)
{
if(types[i] == R)
levels[i] += 1;
else if((types[i] == AN) || (types[i] == EN))
levels[i] += 2;
}else
{
if((types[i] == L) ||
(types[i] == EN) ||
(types[i] == AN))
levels[i] += 1;
}
}
/* Rule (I2)
* I2. For all characters with an odd (right-to-left) embedding direction,
* those of type L, EN or AN go up one level.
*/
for(i=0; i<count; i++)
{
if((levels[i] % 2) == 1)
{
if(types[i] == L || types[i] == EN || types[i] == AN)
levels[i] += 1;
}
}
/* Rule (L1)
* L1. On each line, reset the embedding level of the following characters
* to the paragraph embedding level:
* (1)segment separators, (2)paragraph separators,
* (3)any sequence of whitespace characters preceding
* a segment separator or paragraph separator,
* (4)and any sequence of white space characters
* at the end of the line.
* The types of characters used here are the original types, not those
* modified by the previous phase.
*/
j=count-1;
while(j>0 && (GetType(GETCHAR(line, j)) == WS))
{
j--;
}
if(j < (count-1))
{
for(j++; j<count; j++)
levels[j] = paragraphLevel;
}
for(i=0; i<count; i++)
{
tempType = GetType(GETCHAR(line, i));
if(tempType == WS)
{
j=i;
while((++j < count) && ((tempType == WS) || (tempType == RLE)) )
{
tempType = GetType(line[j]);
}
if(GetType(GETCHAR(line, j)) == B || GetType(GETCHAR(line, j)) == S)
{
for(j--; j>=i ; j--)
{
levels[j] = paragraphLevel;
}
}
}else if(tempType == B || tempType == S)
levels[i] = paragraphLevel;
}
/* Rule (L4)
* L4. A character that possesses the mirrored property as specified by
* Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
* resolved directionality of that character is R.
*/
/* Note: this is implemented before L2 for efficiency */
for(i=0; i<count; i++)
{
if((levels[i] % 2) == 1)
doMirror(&GETCHAR(line, i));
}
/* Rule (L3)
* L3. Combining marks applied to a right-to-left base character will at
* this point precede their base character. If the rendering engine
* expects them to follow the base characters in the final display
* process, then the ordering of the marks and the base character must
* be reversed.
* Combining marks are reordered to the right of each character on an
* odd level.
*/
if(fNSM && reorderCombining)
{
CHARTYPE temp;
int it;
for(i=0; i<count; i++)
{
if(GetType(GETCHAR(line, i)) == NSM && odd(levels[i]))
{
j=i;
while((++j < count) && (GetType(GETCHAR(line, j)) == NSM));
j--; i--;
for(it=j; j>i; i++, j--)
{
temp = GETCHAR(line, i);
GETCHAR(line, i) = GETCHAR(line, j);
GETCHAR(line, j) = temp;
if(v2l)
{
tempInt = v2l[i];
v2l[i] = v2l[j];
v2l[j] = tempInt;
}
}
i=it+1;
}
}
}
/* Shaping
* Shaping is Applied to each run of levels separately....
*/
if(applyShape)
{
for(i=0; i<count; i++)
{
shapeTo[i] = GETCHAR(line, i);
}
j=i=0;
while(j < count)
{
if(GetType(GETCHAR(line, j)) == AL)
{
if(j<count && j >= i )
{
tempType = levels[j];
i=j;
while((i++ < count) && (levels[i] == tempType));
doShape(line, shapeTo, j, i);
j=i;
tempType = levels[j];
}
}
j++;
}
for(i=0; i<count; i++)
{
GETCHAR(line, i) = shapeTo[i];
}
free(shapeTo);
}
/* Rule (L2)
* L2. From the highest level found in the text to the lowest odd level on
* each line, including intermediate levels not actually present in the
* text, reverse any contiguous sequence of characters that are at that
* level or higher
*/
/* we flip the character string and leave the level array */
imax = 0;
i=0;
tempType = levels[0];
while(i < count)
{
if(levels[i] > tempType)
{
tempType = levels[i];
imax=i;
}
i++;
}
/* maximum level in tempType, its index in imax. */
while(tempType > 0) /* loop from highest level to the least odd, */
{ /* which i assume is 1 */
flipThisRun(line, levels, tempType, count, v2l);
tempType--;
}
free(types);
free(levels);
if (l2v && v2l)
{
for(i=0; i<count; i++)
{
l2v[v2l[i]] = i;
}
}
return count;
}
/*!
* @brief Main function
*/
int main(void)
{
adc16_config_t adc16ConfigStruct;
adc16_channel_config_t adc16ChannelConfigStruct;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
EnableIRQ(DEMO_ADC16_IRQn);
PRINTF("\r\nADC16 interrupt Example.\r\n");
/*
* adc16ConfigStruct.referenceVoltageSource = kADC16_ReferenceVoltageSourceVref;
* adc16ConfigStruct.clockSource = kADC16_ClockSourceAsynchronousClock;
* adc16ConfigStruct.enableAsynchronousClock = true;
* adc16ConfigStruct.clockDivider = kADC16_ClockDivider8;
* adc16ConfigStruct.resolution = kADC16_ResolutionSE12Bit;
* adc16ConfigStruct.longSampleMode = kADC16_LongSampleDisabled;
* adc16ConfigStruct.enableHighSpeed = false;
* adc16ConfigStruct.enableLowPower = false;
* adc16ConfigStruct.enableContinuousConversion = false;
*/
ADC16_GetDefaultConfig(&adc16ConfigStruct);
ADC16_Init(DEMO_ADC16_BASE, &adc16ConfigStruct);
ADC16_EnableHardwareTrigger(DEMO_ADC16_BASE, false); /* Make sure the software trigger is used. */
#if defined(FSL_FEATURE_ADC16_HAS_CALIBRATION) && FSL_FEATURE_ADC16_HAS_CALIBRATION
if (kStatus_Success == ADC16_DoAutoCalibration(DEMO_ADC16_BASE))
{
PRINTF("ADC16_DoAutoCalibration() Done.\r\n");
}
else
{
PRINTF("ADC16_DoAutoCalibration() Failed.\r\n");
}
#endif /* FSL_FEATURE_ADC16_HAS_CALIBRATION */
PRINTF("Press any key to get user channel's ADC value ...\r\n");
adc16ChannelConfigStruct.channelNumber = DEMO_ADC16_USER_CHANNEL;
adc16ChannelConfigStruct.enableInterruptOnConversionCompleted = true; /* Enable the interrupt. */
#if defined(FSL_FEATURE_ADC16_HAS_DIFF_MODE) && FSL_FEATURE_ADC16_HAS_DIFF_MODE
adc16ChannelConfigStruct.enableDifferentialConversion = false;
#endif /* FSL_FEATURE_ADC16_HAS_DIFF_MODE */
g_Adc16InterruptCounter = 0U;
while (1)
{
GETCHAR();
g_Adc16ConversionDoneFlag = false;
/*
When in software trigger mode, each conversion would be launched once calling the "ADC16_ChannelConfigure()"
function, which works like writing a conversion command and executing it. For another channel's conversion,
just to change the "channelNumber" field in channel configuration structure, and call the function
"ADC16_ChannelConfigure()"" again.
Also, the "enableInterruptOnConversionCompleted" inside the channel configuration structure is a parameter for
the conversion command. It takes affect just for the current conversion. If the interrupt is still required
for the following conversion, it is necessary to assert the "enableInterruptOnConversionCompleted" every time
for each command.
*/
ADC16_SetChannelConfig(DEMO_ADC16_BASE, DEMO_ADC16_CHANNEL_GROUP, &adc16ChannelConfigStruct);
while (!g_Adc16ConversionDoneFlag)
{
}
PRINTF("ADC Value: %d\r\n", g_Adc16ConversionValue);
PRINTF("ADC Interrupt Count: %d\r\n", g_Adc16InterruptCounter);
}
}
/* The Main shaping function, and the only one to be used
* by the outside world.
*
* line: buffer to apply shaping to. this must be passed by doBidi() first
* to: output buffer for the shaped data
* from: start bidi at this index
* count: number of characters in line
*/
int doShape(BLOCKTYPE line, CHARTYPE* to, int from, int count)
{
int i, j, ligFlag;
unsigned char prevTemp, nextTemp;
CHARTYPE tempChar;
ligFlag = 0;
prevTemp = SU;
nextTemp = SU;
for(i=from; i<count; i++)
{
/* Get Previous and next Characters type */
j=i;
while(--j >= 0)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
prevTemp = STYPE(GETCHAR(line, j));
break;
}
}
j=i;
while(++j < count)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
nextTemp = STYPE(GETCHAR(line, j));
break;
}else if(j == count-1)
{
nextTemp = SU;
break;
}
}
switch(STYPE(GETCHAR(line, i)))
{
case SC:
case SU:
to[i] = GETCHAR(line, i);
break;
case SR:
if(prevTemp == SD || prevTemp == SC)
to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SISOLATED(GETCHAR(line, i));
break;
case SD:
/* Make Ligatures */
if(GETCHAR(line, i) == 0x644)
{
j=i;
while(j++<count)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
tempChar = GETCHAR(line, j);
break;
}
}
switch(tempChar)
{
case 0x622:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEF6;
else
to[i] = 0xFEF5;
break;
case 0x623:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEF8;
else
to[i] = 0xFEF7;
break;
case 0x625:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEFA;
else
to[i] = 0xFEF9;
break;
case 0x627:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEFC;
else
to[i] = 0xFEFB;
break;
}
if(ligFlag)
{
to[j] = 0x20;
i = j;
ligFlag = 0;
break;
}
}
if((prevTemp == SD) || (prevTemp == SC))
{
if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
to[i] = SMEDIAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
break;
}else
{
if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
to[i] = SINITIAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SISOLATED(GETCHAR(line, i));
break;
}
}
nextTemp = SU;
}
return 1;
}
/*
* chap_handle_response - check the response to our challenge.
*/
static void chap_handle_response(ppp_pcb *pcb, int id,
unsigned char *pkt, int len) {
int response_len, ok, mlen;
const unsigned char *response;
unsigned char *outp;
struct pbuf *p;
const char *name = NULL; /* initialized to shut gcc up */
#if 0 /* UNUSED */
int (*verifier)(const char *, const char *, int, const struct chap_digest_type *,
const unsigned char *, const unsigned char *, char *, int);
#endif /* UNUSED */
char rname[MAXNAMELEN+1];
char message[256];
if ((pcb->chap_server.flags & LOWERUP) == 0)
return;
if (id != pcb->chap_server.challenge[PPP_HDRLEN+1] || len < 2)
return;
if (pcb->chap_server.flags & CHALLENGE_VALID) {
response = pkt;
GETCHAR(response_len, pkt);
len -= response_len + 1; /* length of name */
name = (char *)pkt + response_len;
if (len < 0)
return;
if (pcb->chap_server.flags & TIMEOUT_PENDING) {
pcb->chap_server.flags &= ~TIMEOUT_PENDING;
UNTIMEOUT(chap_timeout, pcb);
}
#if PPP_REMOTENAME
if (pcb->settings.explicit_remote) {
name = pcb->remote_name;
} else
#endif /* PPP_REMOTENAME */
{
/* Null terminate and clean remote name. */
ppp_slprintf(rname, sizeof(rname), "%.*v", len, name);
name = rname;
}
#if 0 /* UNUSED */
if (chap_verify_hook)
verifier = chap_verify_hook;
else
verifier = chap_verify_response;
ok = (*verifier)(name, pcb->chap_server.name, id, pcb->chap_server.digest,
pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN,
response, pcb->chap_server.message, sizeof(pcb->chap_server.message));
#endif /* UNUSED */
ok = chap_verify_response(pcb, name, pcb->chap_server.name, id, pcb->chap_server.digest,
pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN,
response, message, sizeof(message));
#if 0 /* UNUSED */
if (!ok || !auth_number()) {
#endif /* UNUSED */
if (!ok) {
pcb->chap_server.flags |= AUTH_FAILED;
ppp_warn("Peer %q failed CHAP authentication", name);
}
} else if ((pcb->chap_server.flags & AUTH_DONE) == 0)
return;
/* send the response */
mlen = strlen(message);
len = CHAP_HDRLEN + mlen;
p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +len), PPP_CTRL_PBUF_TYPE);
if(NULL == p)
return;
if(p->tot_len != p->len) {
pbuf_free(p);
return;
}
outp = (unsigned char *)p->payload;
MAKEHEADER(outp, PPP_CHAP);
outp[0] = (pcb->chap_server.flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS;
outp[1] = id;
outp[2] = len >> 8;
outp[3] = len;
if (mlen > 0)
memcpy(outp + CHAP_HDRLEN, message, mlen);
ppp_write(pcb, p);
if (pcb->chap_server.flags & CHALLENGE_VALID) {
pcb->chap_server.flags &= ~CHALLENGE_VALID;
if (!(pcb->chap_server.flags & AUTH_DONE) && !(pcb->chap_server.flags & AUTH_FAILED)) {
#if 0 /* UNUSED */
/*
* Auth is OK, so now we need to check session restrictions
* to ensure everything is OK, but only if we used a
* plugin, and only if we're configured to check. This
* allows us to do PAM checks on PPP servers that
* authenticate against ActiveDirectory, and use AD for
* account info (like when using Winbind integrated with
* PAM).
*/
if (session_mgmt &&
session_check(name, NULL, devnam, NULL) == 0) {
pcb->chap_server.flags |= AUTH_FAILED;
ppp_warn("Peer %q failed CHAP Session verification", name);
}
#endif /* UNUSED */
}
if (pcb->chap_server.flags & AUTH_FAILED) {
auth_peer_fail(pcb, PPP_CHAP);
} else {
if ((pcb->chap_server.flags & AUTH_DONE) == 0)
auth_peer_success(pcb, PPP_CHAP,
pcb->chap_server.digest->code,
name, strlen(name));
if (pcb->settings.chap_rechallenge_time) {
pcb->chap_server.flags |= TIMEOUT_PENDING;
TIMEOUT(chap_timeout, pcb,
pcb->settings.chap_rechallenge_time);
}
}
pcb->chap_server.flags |= AUTH_DONE;
}
}
/* ------------------------------------------------------------------------- */
int tx_zmodem(s_protinfo *pi, bool caller)
{
int startblk = 64; /* Initial Zmodem block size */
int minblk = 64; /* Minimal Z-protocol block size */
int maxblk = 1024;/* Maximal Z-protocol block size */
int blocklen = 0; /* Length of transmitted blocks */
int goodblk = 0; /* How many blocks we sent w/o ZRPOS'tion :) */
int txwindow = 0; /* Tranmitter window size (0 means streaming) */
int newcnt = 0; /* Count free bytes in receiver's buffer */
int rxbuflen = 0; /* Receiver's max buffer length */
int rxlastpos = 0; /* Receiver's last reported offset */
int beenhere = 0; /* How many times we've been ZRPOS'd same place */
long bytescnt = 0; /* Received bytes(current offset) */
long lastsync = 0; /* Last offset to which we got a ZRPOS */
char zconv = 0; /* Local ZMODEM file conversion request */
char zmanag = 0; /* Local ZMODEM file management request */
char ztrans = 0; /* Local ZMODEM file translation request */
char zexten = 0; /* Local ZMODEM file extended options */
char *txbuf = NULL;/* Buffer with ZMAXBLOCKLEN size */
int zrinitcnt = 0; /* Count received ZRINITs */
int rxflags1 = 0;
int rxflags2 = 0;
int txtries = 0;
int junkcnt = 0;
int initacked = 0; /* TRUE when at least one ZRQINIT was sent */
/* after first ZRINIT was received */
int rc = 0; /* Our return code */
int dtype, n;
int ftype;
char c, *p;
long unsigned crc32;
enum ztxstates txstate;
time_t deadtimer;
log("start %s send", Protocols[state.handshake->protocol]);
DEB((D_PROT, "start %s send", Protocols[state.handshake->protocol]));
/* Set time transfer started at */
if( pi->start_time == 0 )
pi->start_time = time(NULL);
txbuf = (char *)xmalloc(ZMAXBLOCKLEN+1);
zconv = ZCBIN;
maxblk = (state.handshake->protocol == PROT_ZMODEM) ? 1024 : 8192;
/* Set initial block size (default is 128b) */
if( (startblk = conf_number(cf_zmodem_start_block_size)) > 0 )
{
if( startblk%64 || startblk > maxblk || startblk < 64 )
startblk = 256;
} else
startblk = 256;
blocklen = startblk;
txwindow = conf_number(cf_zmodem_tx_window);
Z_Rxwait = ZWAITTIME;
Z_Rxtout = ZRXTIMEOUT;
txstate = ZTX_START;
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout);
/*
* At zmodem batches send empty netmail packet
* if no real outgoing traffic available
*/
if( !pi->send_left_size && conf_boolean(cf_zmodem_send_dummy_pkt) )
zmodem_add_empty_packet(pi);
while(1)
{
if( timer_expired(deadtimer) )
{
log("brain dead! (abort)");
gotoexit(PRC_LOCALABORTED);
}
if( txstate == ZTX_RQINIT || txstate == ZTX_FINFO
|| txstate == ZTX_EOF || txstate == ZTX_FIN )
{
#ifdef DEBUG
if( txtries ) DEB((D_PROT, "tx_zmodem: try #%d", txtries));
#endif
if( ++txtries > ZMAXTRIES )
{
log("out of tries");
gotoexit(PRC_LOCALABORTED);
}
}
switch(txstate) {
case ZTX_START:
DEB((D_PROT, "tx_zmodem: entering state ZTX_START"));
if( PUTSTR("rz\r") < 0 )
gotoexit(PRC_ERROR);
txtries = 0;
txstate = ZTX_RQINIT;
break;
case ZTX_RQINIT:
DEB((D_PROT, "tx_zmodem: entering state ZTX_RQINIT"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_RQINITACK;
break;
case ZTX_NEXTFILE:
DEB((D_PROT, "tx_zmodem: entering state ZTX_NEXTFILE"));
if (pi->send) p_tx_fclose(pi);
txtries = 0;
txstate = p_tx_fopen(pi, NULL) ? ZTX_FIN : ZTX_FINFO;
log("nextfile next state: %d", txstate);
break;
case ZTX_FINFO:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FINFO"));
zrinitcnt = 0;
strnxcpy(txbuf, pi->send->net_name, ZMAXFNAME);
p = txbuf + strlen(txbuf) + 1;
sprintf(p, "%ld %lo %lo 0 %ld %ld",
(long)pi->send->bytes_total, (long)pi->send->mod_time,
(long)pi->send->mode, (long)pi->send_left_num,
(long)pi->send_left_size);
DEB((D_PROT, "tx_zmodem: send \"%s\\000%s\"", txbuf, p));
Z_Txhdr[ZF0] = zconv; /* file conversion request */
Z_Txhdr[ZF1] = zmanag; /* file management request */
Z_Txhdr[ZF2] = ztrans; /* file transport request */
Z_Txhdr[ZF3] = zexten;
if( zsbhdr(ZFILE, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
if( zsdata(txbuf, (p - txbuf) + strlen(p), ZCRCW, 0) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINFOACK;
break;
case ZTX_STARTDATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_STARTDATA"));
newcnt = rxbuflen;
junkcnt = 0;
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZDATA, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_DATA;
break;
case ZTX_DATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_DATA"));
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout); /* Remove annoing timeouts! */
if( (n = p_tx_readfile(txbuf, blocklen, pi)) < 0 )
{
/* error occured, remote wait for DATA */
/* so send null ZCRCE data subpacket */
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_NEXTFILE;
break;
}
if( pi->send->eofseen )
dtype = ZCRCE;
else if( junkcnt > 6 )
dtype = ZCRCW;
else if( bytescnt == lastsync )
dtype = ZCRCW;
else if( rxbuflen && (newcnt -= n) <= 0 )
dtype = ZCRCW;
else if( txwindow && (bytescnt - rxlastpos + n) >= txwindow )
dtype = ZCRCQ;
else
dtype = ZCRCG;
if( (rc = p_info(pi, 0)) )
gotoexit(rc);
if( zsdata(txbuf, n, dtype, pi->send->bytes_sent) < 0 )
gotoexit(PRC_ERROR);
if( ++goodblk > 5 && blocklen*2 <= maxblk )
{
goodblk = 0;
blocklen *= 2;
DEB((D_PROT, "tx_zmodem: new blocklen = %ld byte(s)", blocklen));
}
bytescnt = pi->send->bytes_sent += n;
if( dtype == ZCRCW )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCWACK;
break;
}
else if( dtype == ZCRCQ )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCQACK;
break;
}
else if( dtype == ZCRCE )
{
txtries = 0;
txstate = ZTX_EOF;
break;
}
if( CHARWAIT(0) )
{
while( (rc = GETCHAR(1)) != ZTIMER )
{
if( rc < 0 )
{
gotoexit(PRC_ERROR);
}
else if( rc == CAN || rc == ZPAD )
{
DEB((D_PROT, "tx_zmodem: got ZPAD or CAN!"));
setalarm(Z_Rxtout);
txstate = ZTX_READCHECK;
break;
}
else if( rc == XOFF || rc == (XOFF|0200) )
{
DEB((D_PROT, "tx_zmodem: got XOFF"));
if( GETCHAR(5) < 0 )
gotoexit(PRC_ERROR);
break;
}
else if( rc == XON || rc == (XON|0200) )
{
DEB((D_PROT, "tx_zmodem: got XON"));
}
else
{
junkcnt++;
DEB((D_PROT, "tx_zmodem: got JUNK = 0x%x (junkcnt = %d)",
rc, junkcnt));
}
} /* end of while( rc != ZTIMER ) */
} /* end of if( CHARWAIT(0) ) */
break;
case ZTX_EOF:
DEB((D_PROT, "tx_zmodem: entering state ZTX_EOF"));
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZEOF, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_EOFACK;
break;
case ZTX_FIN:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FIN"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINACK;
break;
default:
/* Ignore them all */
break;
} /* end of switch(txstate) */
if( txstate != ZTX_START && txstate != ZTX_RQINIT
&& txstate != ZTX_FINFO && txstate != ZTX_DATA
&& txstate != ZTX_EOF && txstate != ZTX_FIN )
{
switch( ftype = zgethdr(Z_Rxhdr) ) {
case ZCAN:
gotoexit(PRC_REMOTEABORTED);
break;
case ZHANGUP:
case ZEXIT:
gotoexit(PRC_ERROR);
break;
case ZTIMER:
log("time out");
if( txstate == ZTX_READCHECK )
zsdata(txbuf, 0, ZCRCE, 0);
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_READCHECK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCWACK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCQACK: txstate = ZTX_STARTDATA; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZERROR:
case ZCRCERR:
/* NAK them all! */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
break;
case ZRQINIT:
if( txstate == ZTX_RQINITACK )
{
if( Z_Rxhdr[0] == ZCOMMAND )
break;
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
else if( txstate == ZTX_FINFOACK )
{
/* remote is sender - abort */
log("zmodem: remote is sender");
gotoexit(PRC_LOCALABORTED);
}
break;
case ZRINIT:
if( txstate == ZTX_RQINITACK )
{
if( initacked == 0 )
{
/* Be sure ack first ZRINIT */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
initacked = 1;
}
/* Get receiver's options */
rxflags1 = (0377 & Z_Rxhdr[ZF0]);
rxflags2 = (0377 & Z_Rxhdr[ZF1]);
Z_Txfcs32 = (rxflags1 & CANFC32);
Z_Ctlesc |= (rxflags1 & TESCCTL);
rxbuflen = (0377 & Z_Rxhdr[ZP0]);
rxbuflen += ((0377 & Z_Rxhdr[ZP1])<<8);
/* No ZCRCQ if remote doesn't indicate */
/* FDX ability */
if( !(rxflags1 & CANFDX) )
txwindow = 0;
DEB((D_PROT, "tx_zmodem: Z_Txfcs32 = %d Z_Ctlesc = %d",
Z_Txfcs32, Z_Ctlesc));
DEB((D_PROT, "tx_zmodem: rxbuflen = %d blocklen = %d",
rxbuflen, blocklen));
DEB((D_PROT, "tx_zmodem: txwindow = %u",
txwindow));
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINFOACK )
{
/* Possible they didn't see */
/* our file information */
if( ++zrinitcnt > 2 )
txstate = ZTX_FINFO;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
/* Assume file normaly sent ? */
log("assume file normaly sent");
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_EOFACK )
{
/* ok, send next */
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINACK )
{
/* Possible we should ignore */
/* first ZRINIT. Because they */
/* didn't see our first ZFIN */
/* But I'm soo lazy .. :)) */
txstate = ZTX_FIN;
}
break;
case ZACK:
if( txstate == ZTX_CRCWACK )
{
rxlastpos = Z_Rxpos;
if( pi->send->bytes_sent == Z_Rxpos )
txstate = ZTX_STARTDATA;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
rxlastpos = Z_Rxpos;
txstate = ZTX_DATA;
}
break;
case ZSKIP:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
if( txstate == ZTX_READCHECK )
CLEAROUT();
pi->send->status = FSTAT_SKIPPED;
log("remote side skipped file");
txstate = ZTX_NEXTFILE;
}
break;
case ZFIN:
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
log(" BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! ");
if( txstate == ZTX_FINACK )
{
if( PUTSTR("OO") == 0 )
FLUSHOUT();
gotoexit(PRC_NOERROR);
}
break;
case ZRPOS:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
rxlastpos = Z_Rxpos;
/* Clear modem buffers */
/* if( txstate != FINFOACK ) SENDBREAK(); */
if( txstate == ZTX_READCHECK ) CLEAROUT();
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
/* Reset EOF flag! */
pi->send->eofseen = FALSE;
/* Check pos */
if( (Z_Rxpos || txstate != ZTX_FINFOACK)
&& p_tx_rewind(pi, Z_Rxpos) )
{
logerr("can't send file from requested position");
/* Open next file for send */
txstate = ZTX_NEXTFILE;
break;
}
if( txstate == ZTX_FINFOACK )
{
if( Z_Rxpos )
{
log("resyncing at offset %d", Z_Rxpos);
pi->send->bytes_skipped = Z_Rxpos;
}
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK )
{
goodblk = 0;
if( lastsync >= Z_Rxpos && ++beenhere > 4 )
if( blocklen > minblk )
{
blocklen /= 2;
DEB((D_PROT, "tx_zmodem: falldown to %ld BlockLen", blocklen));
}
}
lastsync = bytescnt = pi->send->bytes_sent = Z_Rxpos;
if( txstate == ZTX_FINFOACK )
--lastsync;
txstate = ZTX_STARTDATA;
}
break;
case ZNAK:
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZCRC:
if( txstate == ZTX_FINFOACK )
{
log(" Send file's CRC-32 ");
crc32 = 0xFFFFFFFFL;
while( ((c = getc(pi->send->fp)) != EOF) && --Z_Rxpos )
crc32 = updcrc32(c, crc32);
crc32 = ~crc32;
clearerr(pi->send->fp); /* Clear EOF */
fseek(pi->send->fp, 0L, 0);
stohdr(Z_Txhdr, crc32);
if( zsbhdr(ZCRC, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
}
break;
case ZCHALLENGE:
if( txstate == ZTX_RQINITACK )
{
/* Echo receiver's challenge number */
stohdr(Z_Txhdr, Z_Rxpos);
if( zshhdr(ZACK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
break;
case ZCOMMAND:
if( txstate == ZTX_RQINITACK )
{
txstate = ZTX_RQINIT;
}
break;
case ZABORT:
log("remote requested for session abort");
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
gotoexit(PRC_REMOTEABORTED);
break;
case ZFERR:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
pi->send->status = FSTAT_REFUSED;
log("remote side refused file");
txstate = ZTX_NEXTFILE;
}
break;
default:
log("got unexpected frame %d", ftype);
break;
} /* end of switch(hdr) */
} /* end of if */
} /* end of while */
exit:
DEB((D_PROT, "tx_zmodem: SEND exit = %d", rc));
setalarm(0);
if (pi->send) p_tx_fclose(pi);
if( txbuf ) {
free(txbuf);
txbuf = NULL;
}
return(rc);
}
/*!
* @brief main function
*/
int main(void)
{
int32_t currentTemperature = 0;
uint32_t updateBoundariesCounter = 0;
int32_t tempArray[UPDATE_BOUNDARIES_TIME * 2];
lowPowerAdcBoundaries_t boundaries;
/* Init hardware */
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
/* Init using Led in Demo app */
LED1_INIT();
LED2_INIT();
/* Set to allow entering vlps mode */
SMC_SetPowerModeProtection(SMC, kSMC_AllowPowerModeVlp);
/* Calibrate param Temperature sensor */
ADC16_CalibrateParams(DEMO_ADC16_BASEADDR);
/* Initialize Demo ADC */
if (!ADC16_InitHardwareTrigger(DEMO_ADC16_BASEADDR))
{
PRINTF("Failed to do the ADC init\r\n");
return -1;
}
PRINTF("\n\r ADC LOW POWER DEMO\n");
PRINTF("\r The Low Power ADC project is designed to work with the Tower System or in a stand alone setting\n\n");
PRINTF("\r 1. Set your target board in a place where the temperature is constant.\n");
PRINTF("\r 2. Wait until two Led light turns on.\n");
PRINTF("\r 3. Increment or decrement the temperature to see the changes.\n");
PRINTF("\r Wait two led on...\n\r");
/* setup the HW trigger source */
LPTMR_InitTriggerSourceOfAdc(DEMO_LPTMR_BASE);
ADC16_EnableDMA(DEMO_ADC16_BASEADDR, false);
NVIC_EnableIRQ(DEMO_ADC16_IRQ_ID);
/* Warm up microcontroller and allow to set first boundaries */
while (updateBoundariesCounter < (UPDATE_BOUNDARIES_TIME * 2))
{
while (!conversionCompleted)
{
}
currentTemperature = GetCurrentTempValue();
tempArray[updateBoundariesCounter] = currentTemperature;
updateBoundariesCounter++;
conversionCompleted = false;
}
/* Temp Sensor Calibration */
boundaries = TempSensorCalibration(updateBoundariesCounter, tempArray);
updateBoundariesCounter = 0;
/* Two LED is turned on indicating calibration is done */
LED1_ON();
LED2_ON();
/* Wait for user input before beginning demo */
PRINTF("\r Enter any character to begin...\n");
GETCHAR();
PRINTF("\r ---> OK! Main process is running...!\n");
while (1)
{
/* Prevents the use of wrong values */
while (!conversionCompleted)
{
}
/* Get current Temperature Value */
currentTemperature = GetCurrentTempValue();
/* Store temperature values that are going to be use to calculate average temperature */
tempArray[updateBoundariesCounter] = currentTemperature;
if (currentTemperature > boundaries.upperBoundary)
{
LED2_OFF();
LED1_ON();
}
else if (currentTemperature < boundaries.lowerBoundary)
{
LED2_ON();
LED1_OFF();
}
else
{
LED2_ON();
LED1_ON();
}
/* Call update function */
if (updateBoundariesCounter >= (UPDATE_BOUNDARIES_TIME))
{
boundaries = TempSensorCalibration(updateBoundariesCounter, tempArray);
updateBoundariesCounter = 0;
}
else
{
updateBoundariesCounter++;
}
/* Clear conversionCompleted flag */
conversionCompleted = false;
/* Enter to Very Low Power Stop Mode */
SMC_SetPowerModeVlps(SMC);
}
}
/*
* fsm_input - Input packet.
*/
void
fsm_input(fsm *f, u_char *inpacket, int l)
{
u_char *inp = inpacket;
u_char code, id;
int len;
/*
* Parse header (code, id and length).
* If packet too short, drop it.
*/
if (l < HEADERLEN) {
FSMDEBUG((LOG_WARNING, "fsm_input(%x): Rcvd short header.\n",
f->protocol));
return;
}
GETCHAR(code, inp);
GETCHAR(id, inp);
GETSHORT(len, inp);
if (len < HEADERLEN) {
FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd illegal length.\n",
f->protocol));
return;
}
if (len > l) {
FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd short packet.\n",
f->protocol));
return;
}
len -= HEADERLEN; /* subtract header length */
if( f->state == LS_INITIAL || f->state == LS_STARTING ) {
FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd packet in state %d (%s).\n",
f->protocol, f->state, ppperr_strerr[f->state]));
return;
}
FSMDEBUG((LOG_INFO, "fsm_input(%s):%d,%d,%d\n", PROTO_NAME(f), code, id, l));
/*
* Action depends on code.
*/
switch (code) {
case CONFREQ:
fsm_rconfreq(f, id, inp, len);
break;
case CONFACK:
fsm_rconfack(f, id, inp, len);
break;
case CONFNAK:
case CONFREJ:
fsm_rconfnakrej(f, code, id, inp, len);
break;
case TERMREQ:
fsm_rtermreq(f, id, inp, len);
break;
case TERMACK:
fsm_rtermack(f);
break;
case CODEREJ:
fsm_rcoderej(f, inp, len);
break;
default:
if( !f->callbacks->extcode ||
!(*f->callbacks->extcode)(f, code, id, inp, len) ) {
fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
}
break;
}
}
int main(void) {
board_init();
board_console_init(BOARD_DEBUG_BAUD);
SysTick_Config(BOARD_SYSTICK_100MS);
PRINTF("ubirch #1 r0.2 RSA/ECC encryption/signature benchmark\r\n");
if (init_ltc() != 0) PRINTF("No LTC, may crash\r\n");
if (init_trng() != 0) error("failed to initialize TRNG");
if (init_board_key(2048) != 0) error("failed to generate key pair");
if (init_recipient_public_key(recipient_pubkey, recipient_pubkey_length))
error("failed to load recipient public key");
byte cipher[256]; // 256 bytes is large enough to store 2048 bit RSA ciphertext
word32 plaintextLength = strlen(plaintext);
word32 cipherLength = sizeof(cipher);
PRINTF("- signing message with board private key\r\n");
uint32_t total = 0;
int signatureLength = 0;
byte *signature = NULL;
for (int i = 0; i < BENCHMARK_LOOPS; i++) {
const uint32_t start = timer_read();
signatureLength = wc_SignatureGetSize(WC_SIGNATURE_TYPE_RSA, &board_rsa_key, sizeof(board_rsa_key));
signature = malloc((size_t) signatureLength);
if (wc_SignatureGenerate(
WC_HASH_TYPE_SHA256, WC_SIGNATURE_TYPE_RSA,
(const byte *) plaintext, plaintextLength,
signature, (word32 *) &signatureLength,
&board_rsa_key, sizeof(board_rsa_key),
&rng) != 0)
error("failed to sign plain text message");
const uint32_t elapsed = timer_read() - start;
total += elapsed;
char loop_str[64];
sprintf(loop_str, "%d", i);
timestamp(loop_str, elapsed);
}
timestamp("Average:", total / BENCHMARK_LOOPS);
PRINTF("-- SIGNATURE\r\n");
PRINTF("- encrypting message\r\n");
total = 0;
int r = -1;
for (int i = 0; i < BENCHMARK_LOOPS; i++) {
const uint32_t start = timer_read();
r = wc_RsaPublicEncrypt((const byte *) plaintext, plaintextLength, cipher, cipherLength, &recipient_public_key,
&rng);
if (r < 0) error("failed to encrypt message");
const uint32_t elapsed = timer_read() - start;
total += elapsed;
char loop_str[64];
sprintf(loop_str, "%d", i);
timestamp(loop_str, elapsed);
}
timestamp("Average:", total / BENCHMARK_LOOPS);
PRINTF("-- CIPHER (%d bytes)\r\n", r);
wc_FreeRsaKey(&board_rsa_key);
wc_FreeRsaKey(&recipient_public_key);
PRINTF("THE END\r\n");
while (true) {
uint8_t ch = (uint8_t) GETCHAR();
if (ch == '\r') PUTCHAR('\n');
PUTCHAR(ch);
}
}
static int upap_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg) {
int code, id, len;
int mlen, ulen, wlen;
const u_char *user, *pwd, *msg;
const u_char *pstart;
if (plen < UPAP_HEADERLEN)
return 0;
pstart = p;
GETCHAR(code, p);
GETCHAR(id, p);
GETSHORT(len, p);
if (len < UPAP_HEADERLEN || len > plen)
return 0;
if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(upap_codenames))
printer(arg, " %s", upap_codenames[code-1]);
else
printer(arg, " code=0x%x", code);
printer(arg, " id=0x%x", id);
len -= UPAP_HEADERLEN;
switch (code) {
case UPAP_AUTHREQ:
if (len < 1)
break;
ulen = p[0];
if (len < ulen + 2)
break;
wlen = p[ulen + 1];
if (len < ulen + wlen + 2)
break;
user = (const u_char *) (p + 1);
pwd = (const u_char *) (p + ulen + 2);
p += ulen + wlen + 2;
len -= ulen + wlen + 2;
printer(arg, " user="******" password="******"<hidden>");
#endif
break;
case UPAP_AUTHACK:
case UPAP_AUTHNAK:
if (len < 1)
break;
mlen = p[0];
if (len < mlen + 1)
break;
msg = (const u_char *) (p + 1);
p += mlen + 1;
len -= mlen + 1;
printer(arg, " ");
ppp_print_string(msg, mlen, printer, arg);
break;
default:
break;
}
/* print the rest of the bytes in the packet */
for (; len > 0; --len) {
GETCHAR(code, p);
printer(arg, " %.2x", code);
}
return p - pstart;
}
/*
* ChapReceiveChallenge - Receive Challenge and send Response.
*/
static void
ChapReceiveChallenge(
chap_state *cstate,
u_char *inp,
int id,
int len)
{
int rchallenge_len;
u_char *rchallenge;
int secret_len;
unsigned char secret[MAXSECRETLEN];
char rhostname[256];
MD5_CTX mdContext;
u_char hash[MD5_SIGNATURE_SIZE];
if (cstate->clientstate == CHAPCS_CLOSED ||
cstate->clientstate == CHAPCS_PENDING) {
CHAPDEBUG(("ChapReceiveChallenge: in state %d", cstate->clientstate));
return;
}
if (len < 2) {
CHAPDEBUG(("ChapReceiveChallenge: rcvd short packet."));
return;
}
GETCHAR(rchallenge_len, inp);
len -= sizeof (u_char) + rchallenge_len; /* now name field length */
if (len < 0) {
CHAPDEBUG(("ChapReceiveChallenge: rcvd short packet."));
return;
}
rchallenge = inp;
INCPTR(rchallenge_len, inp);
if (len >= sizeof(rhostname))
len = sizeof(rhostname) - 1;
BCOPY(inp, rhostname, len);
rhostname[len] = '\000';
/* Microsoft doesn't send their name back in the PPP packet */
if (explicit_remote || (remote_name[0] != 0 && rhostname[0] == 0)) {
strlcpy(rhostname, remote_name, sizeof(rhostname));
CHAPDEBUG(("ChapReceiveChallenge: using '%q' as remote name",
rhostname));
}
/* get secret for authenticating ourselves with the specified host */
if (!get_secret(cstate->unit, cstate->resp_name, rhostname,
secret, &secret_len, 0)) {
secret_len = 0; /* assume null secret if can't find one */
warn("No CHAP secret found for authenticating us to %q", rhostname);
}
/* cancel response send timeout if necessary */
if (cstate->clientstate == CHAPCS_RESPONSE)
UNTIMEOUT(ChapResponseTimeout, cstate);
cstate->resp_id = id;
cstate->resp_transmits = 0;
/* generate MD based on negotiated type */
switch (cstate->resp_type) {
case CHAP_DIGEST_MD5:
MD5Init(&mdContext);
MD5Update(&mdContext, &cstate->resp_id, 1);
MD5Update(&mdContext, secret, secret_len);
MD5Update(&mdContext, rchallenge, rchallenge_len);
MD5Final(hash, &mdContext);
BCOPY(hash, cstate->response, MD5_SIGNATURE_SIZE);
cstate->resp_length = MD5_SIGNATURE_SIZE;
break;
#ifdef CHAPMS
case CHAP_MICROSOFT:
ChapMS(cstate, rchallenge, rchallenge_len, secret, secret_len);
break;
#endif
default:
CHAPDEBUG(("unknown digest type %d", cstate->resp_type));
return;
}
BZERO(secret, sizeof(secret));
ChapSendResponse(cstate);
}
void GDTokenizerText::_advance() {
if (error_flag) {
//parser broke
_make_error(last_error);
return;
}
if (code_pos>=len) {
_make_token(TK_EOF);
return;
}
#define GETCHAR(m_ofs) ((m_ofs+code_pos)>=len?0:_code[m_ofs+code_pos])
#define INCPOS(m_amount) { code_pos+=m_amount; column+=m_amount; }
while (true) {
bool is_node_path=false;
switch(GETCHAR(0)) {
case 0:
_make_token(TK_EOF);
break;
case '\\':
INCPOS(1);
if (GETCHAR(0)=='\r') {
INCPOS(1);
}
if (GETCHAR(0)!='\n') {
_make_error("Expected newline after '\\'.");
return;
}
INCPOS(1);
while(GETCHAR(0)==' ' || GETCHAR(0)=='\t') {
INCPOS(1);
}
continue;
case '\t':
case '\r':
case ' ':
INCPOS(1);
continue;
case '\n': {
line++;
INCPOS(1);
column=0;
int i=0;
while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') {
i++;
}
_make_newline(i);
return;
}
#if 1 //py style tokenizer
case '#': { // line comment skip
while(GETCHAR(0)!='\n') {
code_pos++;
if (GETCHAR(0)==0) { //end of file
_make_error("Unterminated Comment");
return;
}
}
INCPOS(1);
column=0;
line++;
int i=0;
while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') {
i++;
}
_make_newline(i);
return;
} break;
#endif
case '/': {
switch(GETCHAR(1)) {
#if 0 // c style tokenizer
case '*': { // block comment
int pos = code_pos+2;
int new_line=line;
int new_col=column+2;
while(true) {
if (_code[pos]=='0') {
_make_error("Unterminated Comment");
code_pos=pos;
return;
}
if (_code[pos]=='*' && _code[pos+1]=='/') {
new_col+=2;
pos+=2; //compensate
break;
} else if (_code[pos]=='\n') {
new_line++;
new_col=0;
} else {
new_col++;
}
pos++;
}
column=new_col;
line=new_line;
code_pos=pos;
continue;
} break;
case '/': { // line comment skip
while(GETCHAR(0)!='\n') {
code_pos++;
if (GETCHAR(0)==0) { //end of file
_make_error("Unterminated Comment");
return;
}
}
INCPOS(1);
column=0;
line++;
continue;
} break;
#endif
case '=': { // diveq
_make_token(TK_OP_ASSIGN_DIV);
INCPOS(1);
} break;
default:
_make_token(TK_OP_DIV);
}
} break;
case '=': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_EQUAL);
INCPOS(1);
} else
_make_token(TK_OP_ASSIGN);
} break;
case '<': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_LESS_EQUAL);
INCPOS(1);
} else if (GETCHAR(1)=='<') {
if (GETCHAR(2)=='=') {
_make_token(TK_OP_ASSIGN_SHIFT_LEFT);
INCPOS(1);
} else {
_make_token(TK_OP_SHIFT_LEFT);
}
INCPOS(1);
} else
_make_token(TK_OP_LESS);
} break;
case '>': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_GREATER_EQUAL);
INCPOS(1);
} else if (GETCHAR(1)=='>') {
if (GETCHAR(2)=='=') {
_make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
INCPOS(1);
} else {
_make_token(TK_OP_SHIFT_RIGHT);
}
INCPOS(1);
} else {
_make_token(TK_OP_GREATER);
}
} break;
case '!': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_NOT_EQUAL);
INCPOS(1);
} else {
_make_token(TK_OP_NOT);
}
} break;
//case '"' //string - no strings in shader
//case '\'' //string - no strings in shader
case '{':
_make_token(TK_CURLY_BRACKET_OPEN);
break;
case '}':
_make_token(TK_CURLY_BRACKET_CLOSE);
break;
case '[':
_make_token(TK_BRACKET_OPEN);
break;
case ']':
_make_token(TK_BRACKET_CLOSE);
break;
case '(':
_make_token(TK_PARENTHESIS_OPEN);
break;
case ')':
_make_token(TK_PARENTHESIS_CLOSE);
break;
case ',':
_make_token(TK_COMMA);
break;
case ';':
_make_token(TK_SEMICOLON);
break;
case '?':
_make_token(TK_QUESTION_MARK);
break;
case ':':
_make_token(TK_COLON); //for methods maybe but now useless.
break;
case '^': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_BIT_XOR);
INCPOS(1);
} else {
_make_token(TK_OP_BIT_XOR);
}
} break;
case '~':
_make_token(TK_OP_BIT_INVERT);
break;
case '&': {
if (GETCHAR(1)=='&') {
_make_token(TK_OP_AND);
INCPOS(1);
} else if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_BIT_AND);
INCPOS(1);
} else {
_make_token(TK_OP_BIT_AND);
}
} break;
case '|': {
if (GETCHAR(1)=='|') {
_make_token(TK_OP_OR);
INCPOS(1);
} else if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_BIT_OR);
INCPOS(1);
} else {
_make_token(TK_OP_BIT_OR);
}
} break;
case '*': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_MUL);
INCPOS(1);
} else {
_make_token(TK_OP_MUL);
}
} break;
case '+': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_ADD);
INCPOS(1);
//} else if (GETCHAR(1)=='+') {
// _make_token(TK_OP_PLUS_PLUS);
// INCPOS(1);
} else {
_make_token(TK_OP_ADD);
}
} break;
case '-': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_SUB);
INCPOS(1);
//} else if (GETCHAR(1)=='-') {
// _make_token(TK_OP_MINUS_MINUS);
// INCPOS(1);
} else {
_make_token(TK_OP_SUB);
}
} break;
case '%': {
if (GETCHAR(1)=='=') {
_make_token(TK_OP_ASSIGN_MOD);
INCPOS(1);
} else {
_make_token(TK_OP_MOD);
}
} break;
case '@':
if (CharType(GETCHAR(1))!='"') {
_make_error("Unexpected '@'");
return;
}
INCPOS(1);
is_node_path=true;
case '"': {
int i=1;
String str;
while(true) {
if (CharType(GETCHAR(i)==0)) {
_make_error("Unterminated String");
return;
} else if (CharType(GETCHAR(i)=='"')) {
break;
} else if (CharType(GETCHAR(i)=='\\')) {
//escaped characters...
i++;
CharType next = GETCHAR(i);
if (next==0) {
_make_error("Unterminated String");
return;
}
CharType res=0;
switch(next) {
case 'a': res=7; break;
case 'b': res=8; break;
case 't': res=9; break;
case 'n': res=10; break;
case 'v': res=11; break;
case 'f': res=12; break;
case 'r': res=13; break;
case '\'': res='\''; break;
case '\"': res='\"'; break;
case '\\': res='\\'; break;
case 'x': {
//hexnumbarh - oct is deprecated
int read=0;
for(int j=0;j<4;j++) {
CharType c = GETCHAR(i+j);
if (c==0) {
_make_error("Unterminated String");
return;
}
if (!_is_hex(c)) {
if (j==0 || !(j&1)) {
_make_error("Malformed hex constant in string");
return;
} else
break;
}
CharType v;
if (c>='0' && c<='9') {
v=c-'0';
} else if (c>='a' && c<='f') {
v=c-'a';
v+=10;
} else if (c>='A' && c<='F') {
v=c-'A';
v+=10;
} else {
ERR_PRINT("BUG");
v=0;
}
res<<=4;
res|=v;
read++;
}
i+=read-1;
} break;
default: {
_make_error("Invalid escape sequence");
return;
} break;
}
str+=res;
} else {
str+=CharType(GETCHAR(i));
}
i++;
}
INCPOS(i);
if (is_node_path) {
_make_constant(NodePath(str));
} else {
_make_constant(str);
}
} break;
default: {
if (_is_number(GETCHAR(0)) || (GETCHAR(0)=='.' && _is_number(GETCHAR(1)))) {
// parse number
bool period_found=false;
bool exponent_found=false;
bool hexa_found=false;
bool sign_found=false;
String str;
int i=0;
while(true) {
if (GETCHAR(i)=='.') {
if (period_found || exponent_found) {
_make_error("Invalid numeric constant at '.'");
return;
}
period_found=true;
} else if (GETCHAR(i)=='x') {
if (hexa_found || str.length()!=1 || !( (i==1 && str[0]=='0') || (i==2 && str[1]=='0' && str[0]=='-') ) ) {
_make_error("Invalid numeric constant at 'x'");
return;
}
hexa_found=true;
} else if (!hexa_found && GETCHAR(i)=='e') {
if (hexa_found || exponent_found) {
_make_error("Invalid numeric constant at 'e'");
return;
}
exponent_found=true;
} else if (_is_number(GETCHAR(i))) {
//all ok
} else if (hexa_found && _is_hex(GETCHAR(i))) {
} else if ((GETCHAR(i)=='-' || GETCHAR(i)=='+') && exponent_found) {
if (sign_found) {
_make_error("Invalid numeric constant at '-'");
return;
}
sign_found=true;
} else
break;
str+=CharType(GETCHAR(i));
i++;
}
if (!( _is_number(str[str.length()-1]) || (hexa_found && _is_hex(str[str.length()-1])))) {
_make_error("Invalid numeric constant: "+str);
return;
}
INCPOS(str.length());
if (hexa_found) {
int val = str.hex_to_int();
_make_constant(val);
} else if (period_found) {
real_t val = str.to_double();
//print_line("*%*%*%*% to convert: "+str+" result: "+rtos(val));
_make_constant(val);
} else {
int val = str.to_int();
_make_constant(val);
}
return;
}
if (GETCHAR(0)=='.') {
//parse period
_make_token(TK_PERIOD);
break;
}
if (_is_text_char(GETCHAR(0))) {
// parse identifier
String str;
str+=CharType(GETCHAR(0));
int i=1;
while(_is_text_char(GETCHAR(i))) {
str+=CharType(GETCHAR(i));
i++;
}
bool identifier=false;
if (str=="null") {
_make_constant(Variant());
} else if (str=="true") {
_make_constant(true);
} else if (str=="false") {
_make_constant(false);
} else {
bool found=false;
struct _bit { Variant::Type type; const char *text;};
//built in types
static const _bit type_list[]={
//types
{Variant::BOOL,"bool"},
{Variant::INT,"int"},
{Variant::REAL,"float"},
{Variant::STRING,"String"},
{Variant::VECTOR2,"vec2"},
{Variant::VECTOR2,"Vector2"},
{Variant::RECT2,"Rect2"},
{Variant::MATRIX32,"Matrix32"},
{Variant::MATRIX32,"mat32"},
{Variant::VECTOR3,"vec3"},
{Variant::VECTOR3,"Vector3"},
{Variant::_AABB,"AABB"},
{Variant::_AABB,"Rect3"},
{Variant::PLANE,"Plane"},
{Variant::QUAT,"Quat"},
{Variant::MATRIX3,"mat3"},
{Variant::MATRIX3,"Matrix3"},
{Variant::TRANSFORM,"trn"},
{Variant::TRANSFORM,"Transform"},
{Variant::COLOR,"Color"},
{Variant::IMAGE,"Image"},
{Variant::_RID,"RID"},
{Variant::OBJECT,"Object"},
{Variant::INPUT_EVENT,"InputEvent"},
{Variant::NODE_PATH,"NodePath"},
{Variant::DICTIONARY,"dict"},
{Variant::DICTIONARY,"Dictionary"},
{Variant::ARRAY,"Array"},
{Variant::RAW_ARRAY,"RawArray"},
{Variant::INT_ARRAY,"IntArray"},
{Variant::REAL_ARRAY,"FloatArray"},
{Variant::STRING_ARRAY,"StringArray"},
{Variant::VECTOR2_ARRAY,"Vector2Array"},
{Variant::VECTOR3_ARRAY,"Vector3Array"},
{Variant::COLOR_ARRAY,"ColorArray"},
{Variant::VARIANT_MAX,NULL},
};
{
int idx=0;
while(type_list[idx].text) {
if (str==type_list[idx].text) {
_make_type(type_list[idx].type);
found=true;
break;
}
idx++;
}
}
if (!found) {
//built in func?
for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
if (str==GDFunctions::get_func_name(GDFunctions::Function(i))) {
_make_built_in_func(GDFunctions::Function(i));
found=true;
break;
}
}
//keywor
}
if (!found) {
struct _kws { Token token; const char *text;};
static const _kws keyword_list[]={
//ops
{TK_OP_IN,"in"},
{TK_OP_NOT,"not"},
{TK_OP_OR,"or"},
{TK_OP_AND,"and"},
//func
{TK_PR_FUNCTION,"func"},
{TK_PR_FUNCTION,"function"},
{TK_PR_CLASS,"class"},
{TK_PR_EXTENDS,"extends"},
{TK_PR_TOOL,"tool"},
{TK_PR_STATIC,"static"},
{TK_PR_EXPORT,"export"},
{TK_PR_VAR,"var"},
{TK_PR_PRELOAD,"preload"},
{TK_PR_ASSERT,"assert"},
{TK_PR_YIELD,"yield"},
{TK_PR_CONST,"const"},
//controlflow
{TK_CF_IF,"if"},
{TK_CF_ELIF,"elif"},
{TK_CF_ELSE,"else"},
{TK_CF_FOR,"for"},
{TK_CF_WHILE,"while"},
{TK_CF_DO,"do"},
{TK_CF_SWITCH,"switch"},
{TK_CF_BREAK,"break"},
{TK_CF_CONTINUE,"continue"},
{TK_CF_RETURN,"return"},
{TK_CF_PASS,"pass"},
{TK_SELF,"self"},
{TK_ERROR,NULL}
};
int idx=0;
found=false;
while(keyword_list[idx].text) {
if (str==keyword_list[idx].text) {
_make_token(keyword_list[idx].token);
found=true;
break;
}
idx++;
}
}
if (!found)
identifier=true;
}
if (identifier) {
_make_identifier(str);
}
INCPOS(str.length());
return;
}
_make_error("Unknown character");
return;
} break;
}
INCPOS(1);
break;
}
}
/*
* ChapReceiveResponse - Receive and process response.
*/
static void
ChapReceiveResponse(
chap_state *cstate,
u_char *inp,
int id,
int len)
{
u_char *remmd, remmd_len;
int secret_len, old_state;
int code;
char rhostname[256];
MD5_CTX mdContext;
unsigned char secret[MAXSECRETLEN];
u_char hash[MD5_SIGNATURE_SIZE];
if (cstate->serverstate == CHAPSS_CLOSED ||
cstate->serverstate == CHAPSS_PENDING) {
CHAPDEBUG(("ChapReceiveResponse: in state %d", cstate->serverstate));
return;
}
if (id != cstate->chal_id)
return; /* doesn't match ID of last challenge */
/*
* If we have received a duplicate or bogus Response,
* we have to send the same answer (Success/Failure)
* as we did for the first Response we saw.
*/
if (cstate->serverstate == CHAPSS_OPEN) {
ChapSendStatus(cstate, CHAP_SUCCESS);
return;
}
if (cstate->serverstate == CHAPSS_BADAUTH) {
ChapSendStatus(cstate, CHAP_FAILURE);
return;
}
if (len < 2) {
CHAPDEBUG(("ChapReceiveResponse: rcvd short packet."));
return;
}
GETCHAR(remmd_len, inp); /* get length of MD */
remmd = inp; /* get pointer to MD */
INCPTR(remmd_len, inp);
len -= sizeof (u_char) + remmd_len;
if (len < 0) {
CHAPDEBUG(("ChapReceiveResponse: rcvd short packet."));
return;
}
UNTIMEOUT(ChapChallengeTimeout, cstate);
if (len >= sizeof(rhostname))
len = sizeof(rhostname) - 1;
BCOPY(inp, rhostname, len);
rhostname[len] = '\000';
/*
* Get secret for authenticating them with us,
* do the hash ourselves, and compare the result.
*/
code = CHAP_FAILURE;
if (!get_secret(cstate->unit, (explicit_remote? remote_name: rhostname),
cstate->chal_name, secret, &secret_len, 1)) {
warn("No CHAP secret found for authenticating %q", rhostname);
} else {
/* generate MD based on negotiated type */
switch (cstate->chal_type) {
case CHAP_DIGEST_MD5: /* only MD5 is defined for now */
if (remmd_len != MD5_SIGNATURE_SIZE)
break; /* it's not even the right length */
MD5Init(&mdContext);
MD5Update(&mdContext, &cstate->chal_id, 1);
MD5Update(&mdContext, secret, secret_len);
MD5Update(&mdContext, cstate->challenge, cstate->chal_len);
MD5Final(hash, &mdContext);
/* compare local and remote MDs and send the appropriate status */
if (memcmp (hash, remmd, MD5_SIGNATURE_SIZE) == 0)
code = CHAP_SUCCESS; /* they are the same! */
break;
default:
CHAPDEBUG(("unknown digest type %d", cstate->chal_type));
}
}
BZERO(secret, sizeof(secret));
ChapSendStatus(cstate, code);
if (code == CHAP_SUCCESS) {
old_state = cstate->serverstate;
cstate->serverstate = CHAPSS_OPEN;
if (old_state == CHAPSS_INITIAL_CHAL) {
auth_peer_success(cstate->unit, PPP_CHAP, rhostname, len);
}
if (cstate->chal_interval != 0)
TIMEOUT(ChapRechallenge, cstate, cstate->chal_interval);
notice("CHAP peer authentication succeeded for %q", rhostname);
} else {
error("CHAP peer authentication failed for remote host %q", rhostname);
cstate->serverstate = CHAPSS_BADAUTH;
auth_peer_fail(cstate->unit, PPP_CHAP);
}
}
int qcs__parse_qchat_msg(
const char * pmsg, ssize_t pmsg_len,
qcs_msg * msg )
{
char ch;
assert( pmsg && pmsg_len && msg );
qcs__cleanupmsg(msg);
GETCHAR(ch);
switch(ch) {
case '0':
msg->msg = QCS_MSG_REFRESH_REQUEST;
GETSTR(msg->src);
break;
case '1':
msg->msg = QCS_MSG_REFRESH_ACK;
GETSTR(msg->dst);
GETSTR(msg->src);
GETMODE(msg->umode);
if( pmsg_len ) {
/* check for `ACTIVE' bit in qc16 messages */
GETACTIVE(msg->uactive);
} else {
/* uactive=TRUE per default */
msg->uactive = 1;
}
break;
case '2':
msg->msg = QCS_MSG_CHANNEL_BROADCAST;
GETCHAN(msg->chan);
GETSTR(msg->src);
GETSTR(msg->text);
break;
case '4':
msg->msg = QCS_MSG_CHANNEL_JOIN;
GETSTR(msg->src);
GETCHAN(msg->chan);
GETMODE(msg->umode);
/*dummy byte skipped*/
break;
case '5':
msg->msg = QCS_MSG_CHANNEL_LEAVE;
GETSTR(msg->src);
GETCHAN(msg->chan);
/*dummy*/
break;
case 'A':
msg->msg = QCS_MSG_CHANNEL_ME;
GETCHAN(msg->chan);
GETSTR(msg->src);
GETSTR(msg->text);
break;
case '7':
msg->msg = QCS_MSG_MESSAGE_ACK;
GETMODE(msg->umode);
GETSTR(msg->dst);
GETSTR(msg->src);
GETCHAR(ch); /* dummy */
GETSTR(msg->text);
break;
case 'E':
msg->msg = QCS_MSG_MESSAGE_MASS;
GETSTR(msg->src);
GETSTR(msg->dst);
GETSTR(msg->text);
break;
case '6':
msg->msg = QCS_MSG_MESSAGE_SEND;
GETSTR(msg->src);
GETSTR(msg->dst);
GETSTR(msg->text);
break;
case '3':
msg->msg = QCS_MSG_RENAME;
GETSTR(msg->src);
GETSTR(msg->text);
/*dummy*/
break;
case 'D':
msg->msg = QCS_MSG_MODE_CHANGE;
GETSTR(msg->src);
GETMODE(msg->umode);
/* dummy byte passed by */
break;
case 'M':
msg->msg = QCS_MSG_ACTIVE_CHANGE;
GETSTR(msg->src);
GETACTIVE(msg->uactive);
break;
case 'C':
msg->msg = QCS_MSG_TOPIC_REPLY;
GETSTR(msg->dst);
GETSTR(msg->text);
/* add "Main" as msg->chan */
msg->chan = malloc(5);
if(!msg->chan) {
qcs__cleanupmsg(msg);
errno = ENOMEM;
return 0;
}
memcpy(msg->chan, "Main", 5);
break;
case 'B':
msg->msg = QCS_MSG_TOPIC_CHANGE;
GETSTR(msg->text);
/* fill in "Main": this is unsupported in qc,
* thus we need to fill it in */
msg->chan = malloc(5);
if(!msg->chan) {
qcs__cleanupmsg(msg);
errno = ENOMEM;
return 0;
}
memcpy(msg->chan, "Main", 5);
break;
case 'G':
msg->msg = QCS_MSG_INFO_REPLY;
GETSTR(msg->dst);
GETSTR(msg->src);
GETSTR(msg->text);
/* skip 3 strings - not used */
GETSTR(msg->chan);free(msg->chan);
GETSTR(msg->chan);free(msg->chan);
GETSTR(msg->chan);free(msg->chan);
GETSTR(msg->chan);
GETSTR(msg->supp);
break;
case 'F':
msg->msg = QCS_MSG_INFO_REQUEST;
GETSTR(msg->dst);
GETSTR(msg->src);
break;
case 'K':
msg->msg = QCS_MSG_CHANMEMBER_REPLY;
GETSTR(msg->dst);
GETSTR(msg->chan);
GETSTR(msg->src);
break;
case 'L':
msg->msg = QCS_MSG_CHANMEMBER_REQUEST;
GETSTR(msg->src);
break;
case 'O':
msg->msg = QCS_MSG_CHANLIST_REPLY;
GETSTR(msg->dst);
GETSTR(msg->chan);
break;
case 'N':
msg->msg = QCS_MSG_CHANLIST_REQUEST;
GETSTR(msg->src);
break;
case 'H':
GETCHAR(ch);
switch(ch) {
case '1': msg->msg = QCS_MSG_BEEP_ACK; break;
case '0': msg->msg = QCS_MSG_BEEP_SEND; break;
default: errno = ENOMSG;
return 0;
}
GETSTR(msg->dst);
GETSTR(msg->src);
/* dummy byte when 'H1' */
break;
case 'J':
GETCHAR(ch);
switch(ch) {
case '0':msg->msg = QCS_MSG_PRIVATE_OPEN; break;
case '1':msg->msg = QCS_MSG_PRIVATE_CLOSE; break;
case '2':msg->msg = QCS_MSG_PRIVATE_TEXT; break;
case '3':msg->msg = QCS_MSG_PRIVATE_ME; break;
default: errno = ENOMSG;
return 0;
}
GETSTR(msg->src);
GETSTR(msg->dst);
if(ch=='2'||ch=='3') {
GETSTR(msg->text);
}
break;
default:
errno = ENOMSG;
return 0;
}
return 1;
}
/*!
* @brief SPI master DMA non-blocking.
*
* Thid function uses SPI master to send an array to slave
* and receive the array back from slave,
* then compare whether the two buffers are the same.
*/
int main (void)
{
uint8_t loopCount = 0;
uint32_t j;
uint32_t failCount = 0;
uint32_t calculatedBaudRate;
spi_dma_master_state_t spiDmaMasterState;
dma_state_t state;
spi_dma_master_user_config_t userDmaConfig =
{
#if FSL_FEATURE_SPI_16BIT_TRANSFERS
.bitCount = kSpi8BitMode,
#endif
.polarity = kSpiClockPolarity_ActiveHigh,
.phase = kSpiClockPhase_FirstEdge,
.direction = kSpiMsbFirst,
.bitsPerSec = TRANSFER_BAUDRATE
};
// init the hardware, this also sets up up the SPI pins for each specific SoC
hardware_init();
// Init OSA layer.
OSA_Init();
PRINTF("\r\nSPI board to board dma-non-blocking example");
PRINTF("\r\nThis example run on instance %d", (uint32_t)SPI_MASTER_INSTANCE);
PRINTF("\r\nBe sure master's SPI%d and slave's SPI%d are connected\r\n",
(uint32_t)SPI_MASTER_INSTANCE, (uint32_t)SPI_MASTER_INSTANCE);
// Set up and init the master
DMA_DRV_Init(&state);
// Init the dspi module for eDMA operation
SPI_DRV_DmaMasterInit(SPI_MASTER_INSTANCE, &spiDmaMasterState);
SPI_DRV_DmaMasterConfigureBus(SPI_MASTER_INSTANCE,
&userDmaConfig,
&calculatedBaudRate);
if (calculatedBaudRate > userDmaConfig.bitsPerSec)
{
PRINTF("\r\n**Something failed in the master bus config \r\n");
return -1;
}
else
{
PRINTF("\r\nBaud rate in Hz is: %d\r\n", calculatedBaudRate);
}
while(1)
{
// Initialize the source buffer
for (j = 0; j < TRANSFER_SIZE; j++)
{
s_spiSourceBuffer[j] = j + loopCount;
}
// Reset the sink buffer
for (j = 0; j < TRANSFER_SIZE; j++)
{
s_spiSinkBuffer[j] = 0;
}
// Start the transfer
SPI_DRV_DmaMasterTransferBlocking(SPI_MASTER_INSTANCE, NULL, s_spiSourceBuffer,
NULL, TRANSFER_SIZE, MASTER_TRANSFER_TIMEOUT);
while (SPI_DRV_DmaMasterGetTransferStatus(SPI_MASTER_INSTANCE, NULL) == kStatus_SPI_Busy)
{
}
// Delay sometime to wait slave receive and send back data
OSA_TimeDelay(500U);
//Receive data from slave
SPI_DRV_DmaMasterTransfer(SPI_MASTER_INSTANCE, NULL, NULL,
s_spiSinkBuffer, TRANSFER_SIZE);
while (SPI_DRV_DmaMasterGetTransferStatus(SPI_MASTER_INSTANCE, NULL) == kStatus_SPI_Busy)
{
}
// Verify the contents of the master sink buffer
// refer to the slave driver for the expected data pattern
failCount = 0; // reset failCount variable
for (j = 0; j < TRANSFER_SIZE; j++)
{
if (s_spiSinkBuffer[j] != s_spiSourceBuffer[j])
{
failCount++;
}
}
// Print out transmit buffer.
PRINTF("\r\nMaster transmit:");
for (j = 0; j < TRANSFER_SIZE; j++)
{
// Print 16 numbers in a line.
if ((j & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", s_spiSourceBuffer[j]);
}
// Print out receive buffer.
PRINTF("\r\nMaster receive:");
for (j = 0; j < TRANSFER_SIZE; j++)
{
// Print 16 numbers in a line.
if ((j & 0x0F) == 0)
{
PRINTF("\r\n ");
}
PRINTF(" %02X", s_spiSinkBuffer[j]);
}
if (failCount == 0)
{
PRINTF("\r\n Spi master transfer succeed! \r\n");
}
else
{
PRINTF("\r\n **failures detected in Spi master transfer! \r\n");
}
// Wait for press any key.
PRINTF("\r\nPress any key to run again\r\n");
GETCHAR();
loopCount++;
}
}
//******************************************************************************
// Parse DNS address from ipconfig options
//******************************************************************************
Boolean Capi2ReadDnsSrv( PCHProtConfig_t *ipcnfg,
u_long* primaryDns1,
u_long* secDns1,
u_long* primaryDns2,
u_long* secDns2)
{
u_char *input;
u_char code, id, len_pid;
u_short protocol;
int len, t_len;
int i=0;
int type, templ;
u_long DNSsrvr;
u_long l;
*primaryDns1 = 0;
*secDns1 = 0;
*primaryDns2 = 0;
*secDns2 = 0;
IPCPDEBUG(("ReadDnsSrv, read dns_servers"));
/* if option length == 2, no option data */
if (ipcnfg->length == 0)
{
IPCPDEBUG(("Network ignored protocol options"));
/* (Not an error, network does not want to bother) */
return TRUE;
}
len = 0;
if (( ipcnfg->options[len++] & 0x83 ) == 0x81)
{
IPCPDEBUG(("Bad protocol config option"));
return FALSE;
}
t_len = len;
while ( t_len < (ipcnfg->length) )
{
input = (u_char *) &ipcnfg->options[t_len];
GETSHORT(protocol, input);
GETCHAR(len_pid, input);
GETCHAR(code, input);
GETCHAR(id, input);
GETSHORT(len, input);
switch (protocol)
{
/* Check LCP option from the Network */
case PPP_LCP:
break;
/* Check IPCP option from the Network */
case PPP_IPCP:
if ( code == CONFREQ )
{
IPCPDEBUG((" ReadOptions: CONFREQ"));
i=0;
while (i<(len-4))
{
GETCHAR(type, input); //RFC 1661, this is option type
GETCHAR(templ, input); //RFC 1661, next byte is length
GETLONG(l, input); //read but don't use
i += templ;
}
}
else if ( code == CONFACK || code == CONFNAK )
{
IPCPDEBUG((" ReadOptions: CONFACK or CONFNAK"));
i=0;
while (i<(len-4))
{
GETCHAR(type, input); //RFC 1661, this is option type
GETCHAR(templ, input); //RFC 1661, next byte is length
switch (type)
{
case CI_ADDR:
GETLONG(l, input);
IPCPDEBUG(("CI_ADDR"));
break;
case CI_DNSADDR_PRI:
GETLONG(l, input);
DNSsrvr = htonl(l);
*primaryDns1 = DNSsrvr;
IPCPDEBUG(("CI_DNSADDR_PRI =%x", DNSsrvr));
break;
case (CI_DNSADDR_PRI+1):
GETLONG(l, input);
DNSsrvr = htonl(l);
*primaryDns2 = DNSsrvr;
IPCPDEBUG(("CI_DNSADDR_PRI =%x", DNSsrvr));
break;
case CI_DNSADDR_SEC:
GETLONG(l, input);
DNSsrvr = htonl(l);
*secDns1 = DNSsrvr;
IPCPDEBUG(("CI_DNSADDR_SEC"));
break;
case (CI_DNSADDR_SEC+1):
GETLONG(l, input);
DNSsrvr = htonl(l);
*secDns2 = DNSsrvr;
IPCPDEBUG(("CI_DNSADDR_SEC"));
break;
default:
break;
}
i += templ;
}
}
else /* Network had rejected */
{
while(i<(len-4))
{
GETCHAR(type, input);
GETCHAR(templ, input);
switch (type)
{
case CI_DNSADDR_PRI:
IPCPDEBUG(("CI_DNSADDR_PRI rejected"));
break;
case (CI_DNSADDR_PRI+1):
IPCPDEBUG(("CI_DNSADDR_PRI+1 rejected"));
break;
case CI_DNSADDR_SEC:
IPCPDEBUG(("CI_DNSADDR_SEC rejected"));
break;
case (CI_DNSADDR_SEC+1): // Not supported
IPCPDEBUG(("CI_DNSADDR_SEC+1 rejected"));
break;
default:
break;
}
i += templ;
}
IPCPDEBUG((" ReadOptions: IPCP REJed"));
}
break;
default:
break;
}
t_len += (len + 3);
}
return TRUE;
}
rebound lex()//词法分析
{
int i,k=0;
rebound re;
re.Str[0]='\0';
while(c==' '||c=='\t')
GETCHAR();
if(isalpha(c)||c =='_')
{
re.Str[k++]=c;
GETCHAR();
while(isalpha(c)||isdigit(c)||c =='_')
{
if(k<VARLENGTH)
re.Str[k++]=c;
GETCHAR();
}
if (k>VARLENGTH) // 判断标识符是否超过指定长度
{
Error(lineNo,"Identifer is too long!");
re.Str[VARLENGTH]='\0';
}
else re.Str[k]='\0';
if((i=isreserved(re.Str))!=-1)
re.type=i;
else re.type=IDENTF;
}
else if(isdigit(c))
{
if(c!='0')
{ while (isdigit(c))
{
if (k<STRINGLENGTH)
re.Str[k++]=c;
else
k++;
GETCHAR();
}
}
else
{
GETCHAR();
if(isdigit(c)||isalpha(c))
{
Error(lineNo,"Illegal number in this line!");
while(isdigit(c)||isalpha(c))
GETCHAR();
}
re.Str[k++]='0';
}
re.type=INTEGER;
if (c=='.')
{ // 判断是浮点数还是整数
re.Str[k++]=c;
GETCHAR();
if(!isdigit(c))
re.Str[k]='\0';
while (isdigit(c))
{
if (k<STRINGLENGTH)
re.Str[k++]=c;
else
k++;
GETCHAR();
}
re.type=FLOAT;
}
if (k<STRINGLENGTH)
{
if(re.Str[k-1]=='.')//处理 1.空 这种数字
re.Str[k-1]='\0';
else re.Str[k]='\0';
}
else
re.Str[STRINGLENGTH]='\0';
if ((re.intval=atoi(re.Str))>INTLENGTH) // 判断整数是否超出范围
Error(lineNo,"The integer in your program is out of range!");
if ((re.realval=(float)atof(re.Str))>FLOATLENGTH) // 判断浮点数是否超出范围
Error(lineNo,"The realnum in your program is out of range!");
}
else switch (c)
{
case '\'': // 处理字符常量
GETCHAR();
re.ch=c;
re.type=CHAR;
GETCHAR();
if (c!='\'')
Error(lineNo," The char is lack of \' ");
else
GETCHAR();
break;
case '"':
GETCHAR();
while (c!='"')
{
if (k<STRINGLENGTH)
re.Str[k++]=c;
else
k++;
GETCHAR();
}
if (c=='"')
GETCHAR();
if (k<=STRINGLENGTH) // 判断字符串是否过长
re.Str[k]='\0';
else
{
Error(lineNo,"The string is too long!");
re.Str[STRINGLENGTH-1]='\0';
}
re.type=STRING;
break;
case '=':
GETCHAR();
if (c=='=')
{
re.type=EQUAL;
GETCHAR();
}
else
re.type=EVALUE;
break;
case '<': // 处理 <= 和 <
GETCHAR();
if (c=='=')
{
re.type=NLESSTHAN;
GETCHAR();
}
else
re.type=LESSTHAN;
break;
case '>': // 处理 >= 和 >
GETCHAR();
if (c=='=')
{
re.type=NMORETHAN;
GETCHAR();
}
else
re.type=MORETHAN;
break;
case '!': // 处理 !=
GETCHAR();
if (c=='=')
{
re.type=UNEQL;
GETCHAR();
}
else
{
Error(lineNo,"Illegal words in this line");
GETCHAR();
}
break;
case '+':
re.type=PLUS;
GETCHAR();
break;
case '-':
re.type=MINUS;
GETCHAR();
break;
case '*':
re.type=MUL;
GETCHAR();
break;
case '/':
re.type=DIV;
GETCHAR();
break;
case '(':
re.type=LEFTP;
GETCHAR();
break;
case ')':
re.type=RIGHTP;
GETCHAR();
break;
case '{':
re.type=LBRACKET;
GETCHAR();
break;
case '}':
re.type=RBRACKET;
GETCHAR();
break;
case ',':
re.type=COMMA;
GETCHAR();
break;
case ';':
re.type=SEMICOLON;
GETCHAR();
break;
case ':':
re.type=COLON;
GETCHAR();
break;
case -1:
re.type=-1;
GETCHAR();
break;
default:
Error(lineNo,"Your character is beyond the grammar");
GETCHAR();
}
if(re.type == IDENTF)//标识符不区分大小写
{
for(int x=0;re.Str[x]!='\0';x++)
{
if(re.Str[x]>='a'&&re.Str[x]<='z')
re.Str[x]-='a'-'A';
}
}
return re;
}
