/**
* Parse a string for a crtc.
* \param crtc Crtc to write.
* \param begin Start of the string to parse.
* \param end End of the string to parse.
* \return
* - ==0 on success
* - !=0 on error
*/
adv_error crtc_parse(adv_crtc* crtc, const char* begin, const char* end)
{
crtc_reset(crtc);
crtc_user_reset(crtc);
parse_separator(" \t", &begin, end);
if (begin != end && *begin == '"') {
if (parse_quote(crtc->name, CRTC_NAME_MAX, &begin, end))
return -1;
} else {
if (parse_token(crtc->name, CRTC_NAME_MAX, " \t", &begin, end))
return -1;
}
parse_separator(" \t", &begin, end);
if (begin == end) {
snprintf(video_mode_parse_error_buffer, sizeof(video_mode_parse_error_buffer), "Missing modeline data");
return -1;
}
if (parse_crtc(crtc, begin, end) != 0)
return -1;
return 0;
}
pointer parse_expr(parser* parse)
{
eat_whitespace(parse);
pointer ret_car;
pointer ret_cdr;
switch(*parse->curr)
{
case '(':
parse->curr++;
ret_car = parse_expr(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '"':
ret_car = parse_string(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '\'':
parse->curr++;
ret_car = parse_quote(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case ')':
parse->curr++;
return NIL;
case '+': case '-': case 'b':
ret_car = parse_number_or_symbol(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case '.':
return parse_number_or_pair(parse);
case '\\':
parse->curr++;
ret_car = create_char(*(parse->curr++));
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
case ';':
while(!is_newline(*parse->curr) && *parse->curr != '\0')
parse->curr++;
return parse_expr(parse);
case 0:
return NIL;
default:
if(is_number_char(*parse->curr))
{
ret_car = parse_number(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
}
else if(is_symbol_char(*parse->curr))
{
ret_car = parse_symbol(parse);
ret_cdr = parse_expr(parse);
return create_pair(ret_car, ret_cdr);
}
else
return parser_error(parse, "Unexpected char in expression.");
}
parse->curr++;
}
NODE*
parse_any(SCANNER *s, int mode) {
NODE *x = NULL;
int c;
skip_white(s);
if (s_eof(s)) return raise(s, "unexpected end of file");
c = s_peek(s);
if (c == '(') {
s_getc(s);
x = parse_paren(s, mode);
if (x == NULL) return NULL;
if (s_eof(s)) {
return raise(s, "unexpected end of file");
}
skip_white(s);
if (s_getc(s) != ')') {
return invalid_token(s);
}
} else if (c == '\'')
x = parse_quote(s);
else if (c == '`')
return parse_bquote(s);
else if (c == '"')
x = parse_string(s);
else if (isalnum((int)c) || strchr(SYMBOL_CHARS, c))
x = parse_primitive(s);
else
return invalid_token(s);
return x;
}
bool parse_section(const IXMLNode::TXMLNodePtr& pTop, CQuotesProviderBase::CQuoteSection& qs)
{
CQuotesProviderBase::CQuoteSection::TSections aSections;
CQuotesProviderBase::CQuoteSection::TQuotes aQuotes;
tstring sSectionName;
size_t cChild = pTop->GetChildCount();
for (size_t i = 0; i < cChild; ++i) {
IXMLNode::TXMLNodePtr pNode = pTop->GetChildNode(i);
tstring sName = pNode->GetName();
if (0 == mir_tstrcmpi(_T("section"), sName.c_str())) {
CQuotesProviderBase::CQuoteSection qs1;
if (true == parse_section(pNode, qs1))
aSections.push_back(qs1);
}
else if (0 == mir_tstrcmpi(_T("quote"), sName.c_str())) {
CQuotesProviderBase::CQuote q;
if (true == parse_quote(pNode, q))
aQuotes.push_back(q);
}
else if (0 == mir_tstrcmpi(_T("name"), sName.c_str())) {
sSectionName = pNode->GetText();
if (true == sSectionName.empty())
return false;
}
}
qs = CQuotesProviderBase::CQuoteSection(TranslateTS(sSectionName.c_str()), aSections, aQuotes);
return true;
}
format_data_t *
grad_utent_compile_form(char *fmt)
{
format_data_t *form_head = NULL, *form_tail;
slist = grad_slist_create();
while (*fmt) {
int rc;
format_data_t *form = grad_emalloc(sizeof(*form));
if (!form_head)
form_head = form;
else
form_tail->next = form;
form_tail = form;
if (*fmt == '(')
rc = parse_form(&fmt, form);
else if (*fmt == '"' || *fmt == '\'')
rc = parse_quote(&fmt, form);
else
rc = parse_string(&fmt, form);
if (rc) {
form_free(form_head);
form_head = NULL;
break;
}
}
grad_slist_free(&slist);
return form_head;
}
int parse_line(t_line *l, t_ftl_root *hist)
{
if (l->str == NULL)
return (0);
if (parse_history(l, hist) == 1)
return (1);
if (parse_quote(l) == 1)
return (1);
parse_newline(l->str, hist);
return (0);
}
/* Parse password timestamp */
static char *
parse_ts(time_t *tp,
char **valp,
char *val0,
char *delimp,
char *buf,
uint_t bufsize)
{
struct tm tm;
if (0 > parse_quote(valp, "| ,", delimp, buf, bufsize) ||
buf[bufsize-1] != '\0' || buf[bufsize-2] != '\0') {
(void) snprintf(buf, bufsize, "bad timestamp %.25s", val0);
return (buf);
}
(void) strlcat(buf, "\n", bufsize);
(void) memset(&tm, 0, sizeof (tm));
if (5 != sscanf(buf, "%u/%u/%u@%u:%u\n",
(unsigned *)&tm.tm_year, (unsigned *)&tm.tm_mon,
(unsigned *)&tm.tm_mday, (unsigned *)&tm.tm_hour,
(unsigned *)&tm.tm_min) ||
tm.tm_mon < 1 || tm.tm_mon > 12 ||
tm.tm_mday < 1 || tm.tm_mday > 31) {
(void) snprintf(buf, bufsize, "bad timestamp %.25s", val0);
return (buf);
}
tm.tm_mon--;
/* assume small years are in the 3rd millenium */
if (tm.tm_year <= 37)
tm.tm_year += 100;
if (tm.tm_year >= 1900)
tm.tm_year -= 1900;
if ((*tp = mktime(&tm)) == -1) {
(void) snprintf(buf, bufsize, "bad timestamp %.25s", val0);
return (buf);
}
return (NULL);
}
static const char *
next_token (const char *s, char *token, size_t *tokenlen, size_t tokenmax)
{
if (*s == '(')
return (parse_comment (s + 1, token, tokenlen, tokenmax));
if (*s == '"')
return (parse_quote (s + 1, token, tokenlen, tokenmax));
if (is_special (*s)) {
if (*tokenlen < tokenmax)
token[(*tokenlen)++] = *s;
return (s + 1);
}
while (*s) {
if (is_email_wsp(*s) || is_special (*s))
break;
if (*tokenlen < tokenmax)
token[(*tokenlen)++] = *s;
s++;
}
return s;
}
// ------------------------------------------------------------
// parsemain5 : parse line
int parsemain5(void)
{
unsigned char c;
for (;;) {
c = buf_fgetc();
if (c == 0) {
// line end
buf_fputc('\n');
break;
} else {
if ((c >= 0x80) && (c <= 0xf9)) {
// if match, output command strings
buf_fprintf(p6codelist5[c - 0x80]);
if (c == CODEDATA) {
// raw output until return or colon
if (parse_data() == 0x00) {
return(0);
};
} else if (c == CODEREM) {
// raw output until return
parse_rem();
return(0);
}
} else {
// if not code, output 1 byte as is
buf_fputc(c);
if (c == '"') {
// raw output until " or return
if (parse_quote() == 0x00) {
return(0);
};
}
}
}
}
return(0);
}
LPCSTR next_token( LPCSTR s, LPSTR token, size_t * tokenlen, size_t tokenmax )
{
if (*s == '(')
return ( parse_comment(s + 1, token, tokenlen, tokenmax ) );
if (*s == '"')
return ( parse_quote( s + 1, token, tokenlen, tokenmax ) );
if ( is_special( *s ) )
{
if (*tokenlen < tokenmax)
token[(*tokenlen)++] = *s;
return (s + 1);
}
while (*s)
{
if ( isspace( (unsigned char)*s ) || is_special( *s ) )
break;
if ( *tokenlen < tokenmax )
token[ (*tokenlen)++ ] = *s;
s++;
}
return s;
}
ADDRESS *rfc822_parse_adrlist (ADDRESS *top, const char *s)
{
int ws_pending, nl;
#ifdef EXACT_ADDRESS
const char *begin;
#endif
const char *ps;
char comment[LONG_STRING], phrase[LONG_STRING];
size_t phraselen = 0, commentlen = 0;
ADDRESS *cur, *last = NULL;
RFC822Error = 0;
last = top;
while (last && last->next)
last = last->next;
ws_pending = is_email_wsp (*s);
if ((nl = mutt_strlen (s)))
nl = s[nl - 1] == '\n';
s = skip_email_wsp(s);
#ifdef EXACT_ADDRESS
begin = s;
#endif
while (*s)
{
if (*s == ',')
{
if (phraselen)
{
terminate_buffer (phrase, phraselen);
add_addrspec (&top, &last, phrase, comment, &commentlen, sizeof (comment) - 1);
}
else if (commentlen && last && !last->personal)
{
terminate_buffer (comment, commentlen);
last->personal = safe_strdup (comment);
}
#ifdef EXACT_ADDRESS
if (last && !last->val)
last->val = mutt_substrdup (begin, s);
#endif
commentlen = 0;
phraselen = 0;
s++;
#ifdef EXACT_ADDRESS
begin = skip_email_wsp(s);
#endif
}
else if (*s == '(')
{
if (commentlen && commentlen < sizeof (comment) - 1)
comment[commentlen++] = ' ';
if ((ps = next_token (s, comment, &commentlen, sizeof (comment) - 1)) == NULL)
{
rfc822_free_address (&top);
return NULL;
}
s = ps;
}
else if (*s == '"')
{
if (phraselen && phraselen < sizeof (phrase) - 1)
phrase[phraselen++] = ' ';
if ((ps = parse_quote (s + 1, phrase, &phraselen, sizeof (phrase) - 1)) == NULL)
{
rfc822_free_address (&top);
return NULL;
}
s = ps;
}
else if (*s == ':')
{
cur = rfc822_new_address ();
terminate_buffer (phrase, phraselen);
cur->mailbox = safe_strdup (phrase);
cur->group = 1;
if (last)
last->next = cur;
else
top = cur;
last = cur;
#ifdef EXACT_ADDRESS
last->val = mutt_substrdup (begin, s);
#endif
phraselen = 0;
commentlen = 0;
s++;
#ifdef EXACT_ADDRESS
begin = skip_email_wsp(s);
#endif
}
else if (*s == ';')
{
if (phraselen)
{
terminate_buffer (phrase, phraselen);
add_addrspec (&top, &last, phrase, comment, &commentlen, sizeof (comment) - 1);
}
else if (commentlen && last && !last->personal)
{
terminate_buffer (comment, commentlen);
last->personal = safe_strdup (comment);
}
#ifdef EXACT_ADDRESS
if (last && !last->val)
last->val = mutt_substrdup (begin, s);
#endif
/* add group terminator */
cur = rfc822_new_address ();
if (last)
{
last->next = cur;
last = cur;
}
phraselen = 0;
commentlen = 0;
s++;
#ifdef EXACT_ADDRESS
begin = skip_email_wsp(s);
#endif
}
else if (*s == '<')
{
terminate_buffer (phrase, phraselen);
cur = rfc822_new_address ();
if (phraselen)
cur->personal = safe_strdup (phrase);
if ((ps = parse_route_addr (s + 1, comment, &commentlen, sizeof (comment) - 1, cur)) == NULL)
{
rfc822_free_address (&top);
rfc822_free_address (&cur);
return NULL;
}
if (last)
last->next = cur;
else
top = cur;
last = cur;
phraselen = 0;
commentlen = 0;
s = ps;
}
else
{
if (phraselen && phraselen < sizeof (phrase) - 1 && ws_pending)
phrase[phraselen++] = ' ';
if ((ps = next_token (s, phrase, &phraselen, sizeof (phrase) - 1)) == NULL)
{
rfc822_free_address (&top);
return NULL;
}
s = ps;
}
ws_pending = is_email_wsp(*s);
s = skip_email_wsp(s);
}
if (phraselen)
{
terminate_buffer (phrase, phraselen);
terminate_buffer (comment, commentlen);
add_addrspec (&top, &last, phrase, comment, &commentlen, sizeof (comment) - 1);
}
else if (commentlen && last && !last->personal)
{
terminate_buffer (comment, commentlen);
last->personal = safe_strdup (comment);
}
#ifdef EXACT_ADDRESS
if (last)
last->val = mutt_substrdup (begin, s - nl < begin ? begin : s - nl);
#endif
return top;
}
machine_t *prelude__parse_quote(machine_t *machine) {
return parse_quote(machine);
}
/*
* Parse a set of parameters for an interface.
* returns NULL or error message
*/
const char *
parse_parms(char *line,
boolean_t safe) /* 1=from secure file */
{
#define PARS(str) (strcasecmp(tgt, str) == 0)
#define PARSEQ(str) (strncasecmp(tgt, str"=", sizeof (str)) == 0)
/*
* This macro checks for conflicting configurations options
* For eg one can set either the IS_NO_SOL_OUT flag bit or the IS_SOL_OUT flag
* bit, but not both.
*/
#define CKF(g, b) {if (0 != (parm.parm_int_state & ((g) & ~(b)))) break; \
parm.parm_int_state |= (b); }
struct parm parm;
struct intnet *intnetp;
struct r1net *r1netp;
struct tgate *tg;
uint32_t addr, mask;
char delim, *val0 = 0, *tgt, *val, *p;
const char *msg;
char buf[PARMS_MAXLINELEN], buf2[PARMS_MAXLINELEN];
int i;
/* "subnet=x.y.z.u/mask[,metric]" must be alone on the line */
if (strncasecmp(line, "subnet=", sizeof ("subnet=") - 1) == 0 &&
*(val = &line[sizeof ("subnet=") -1 ]) != '\0') {
if (0 > parse_quote(&val, ",", &delim, buf, sizeof (buf)))
return (bad_str(line));
intnetp = rtmalloc(sizeof (*intnetp),
"parse_parms subnet");
intnetp->intnet_metric = 1;
if (delim == ',') {
intnetp->intnet_metric = (int)strtol(val+1, &p, 0);
if (*p != '\0' || intnetp->intnet_metric <= 0 ||
val+1 == p ||
intnetp->intnet_metric >= HOPCNT_INFINITY) {
free(intnetp);
return (bad_str(line));
}
}
if (!getnet(buf, &intnetp->intnet_addr,
&intnetp->intnet_mask) ||
intnetp->intnet_mask == HOST_MASK ||
intnetp->intnet_addr == RIP_DEFAULT) {
free(intnetp);
return (bad_str(line));
}
intnetp->intnet_addr = htonl(intnetp->intnet_addr);
intnetp->intnet_next = intnets;
intnets = intnetp;
return (NULL);
}
/*
* "ripv1_mask=x.y.z.u/mask1,mask2" must be alone on the line.
* This requires that x.y.z.u/mask1 be considered a subnet of
* x.y.z.u/mask2, as if x.y.z.u/mask2 were a class-full network.
*/
if (!strncasecmp(line, "ripv1_mask=", sizeof ("ripv1_mask=") - 1) &&
*(val = &line[sizeof ("ripv1_mask=")-1]) != '\0') {
if (0 > parse_quote(&val, ",", &delim, buf, sizeof (buf)) ||
delim == '\0')
return (bad_str(line));
if ((i = (int)strtol(val+1, &p, 0)) <= 0 || i > 32 ||
*p != '\0')
return (bad_str(line));
r1netp = rtmalloc(sizeof (*r1netp), "parse_parms ripv1_mask");
r1netp->r1net_mask = HOST_MASK << (32-i);
if (!getnet(buf, &r1netp->r1net_net, &r1netp->r1net_match) ||
r1netp->r1net_net == RIP_DEFAULT ||
r1netp->r1net_mask > r1netp->r1net_match) {
free(r1netp);
return (bad_str(line));
}
r1netp->r1net_next = r1nets;
r1nets = r1netp;
return (NULL);
}
(void) memset(&parm, 0, sizeof (parm));
/*
* Support of the following for Solaris backward compatibility
* norip <ifname>
* noripin <ifname>
* noripout <ifname>
*/
if (strncasecmp("norip", line, 5) == 0) {
char cmd[64], ifname[64];
int n;
n = sscanf(line, "%63s %63s\n", cmd, ifname);
if (n != 2) {
/* Not enough parameters */
return (bad_str(line));
}
/*
* Get the interface name and turn on the appropriate
* interface flags
*/
(void) strlcpy(parm.parm_name, ifname, sizeof (parm.parm_name));
if (strcasecmp("norip", cmd) == 0) {
parm.parm_int_state |= IS_NO_RIP;
} else if (strcasecmp("noripin", cmd) == 0) {
parm.parm_int_state |= IS_NO_RIP_IN;
} else if (strcasecmp("noripout", cmd) == 0) {
parm.parm_int_state |= IS_NO_RIP_OUT;
} else {
/* Bad command */
return (bad_str(line));
}
/*
* Look for duplication, and if new,
* link to the rest of the parm entries.
*/
return (insert_parm(&parm));
}
for (;;) {
tgt = line + strspn(line, " ,\n\r");
if (*tgt == '\0' || *tgt == '#')
break;
line = tgt+strcspn(tgt, "= #,\n\r");
delim = *line;
if (delim == '=') {
val0 = ++line;
if (0 > parse_quote(&line, " #,", &delim,
buf, sizeof (buf)))
return (bad_str(tgt));
}
if (delim != '\0') {
for (;;) {
*line = '\0';
if (delim == '#')
break;
++line;
if (!isspace(delim) ||
((delim = *line), !isspace(delim)))
break;
}
}
if (PARSEQ("if")) {
if (parm.parm_name[0] != '\0' ||
strlen(buf) > IF_NAME_LEN)
return (bad_str(tgt));
(void) strlcpy(parm.parm_name, buf,
sizeof (parm.parm_name));
} else if (PARSEQ("addr")) {
/*
* This is a bad idea, because the address based
* sets of parameters cannot be checked for
* consistency with the interface name parameters.
* The parm_net stuff is needed to allow several
* -F settings.
*/
if (!getnet(val0, &addr, &mask) ||
parm.parm_name[0] != '\0')
return (bad_str(tgt));
parm.parm_net = addr;
parm.parm_mask = mask;
parm.parm_name[0] = '\n';
} else if (PARSEQ("passwd")) {
/*
* since cleartext passwords are so weak allow
* them anywhere
*/
msg = get_passwd(tgt, val0, &parm, RIP_AUTH_PW, 1);
if (msg) {
*val0 = '\0';
return (bad_str(msg));
}
} else if (PARSEQ("md5_passwd")) {
msg = get_passwd(tgt, val0, &parm, RIP_AUTH_MD5, safe);
if (msg) {
*val0 = '\0';
return (bad_str(msg));
}
} else if (PARS("no_ag")) {
parm.parm_int_state |= (IS_NO_AG | IS_NO_SUPER_AG);
} else if (PARS("no_host")) {
parm.parm_int_state |= IS_NO_HOST;
} else if (PARS("no_super_ag")) {
parm.parm_int_state |= IS_NO_SUPER_AG;
} else if (PARS("no_ripv1_in")) {
parm.parm_int_state |= IS_NO_RIPV1_IN;
} else if (PARS("no_ripv2_in")) {
parm.parm_int_state |= IS_NO_RIPV2_IN;
} else if (PARS("ripv2_out")) {
if (parm.parm_int_state & IS_NO_RIPV2_OUT)
return (bad_str(tgt));
parm.parm_int_state |= IS_NO_RIPV1_OUT;
} else if (PARS("ripv2")) {
if ((parm.parm_int_state & IS_NO_RIPV2_OUT) ||
(parm.parm_int_state & IS_NO_RIPV2_IN))
return (bad_str(tgt));
parm.parm_int_state |= (IS_NO_RIPV1_IN
| IS_NO_RIPV1_OUT);
} else if (PARS("no_rip")) {
CKF(IS_PM_RDISC, IS_NO_RIP);
} else if (PARS("no_rip_mcast")) {
parm.parm_int_state |= IS_NO_RIP_MCAST;
} else if (PARS("no_rdisc")) {
CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC);
} else if (PARS("no_solicit")) {
CKF(GROUP_IS_SOL_OUT, IS_NO_SOL_OUT);
} else if (PARS("send_solicit")) {
CKF(GROUP_IS_SOL_OUT, IS_SOL_OUT);
} else if (PARS("no_rdisc_adv")) {
CKF(GROUP_IS_ADV_OUT, IS_NO_ADV_OUT);
} else if (PARS("rdisc_adv")) {
CKF(GROUP_IS_ADV_OUT, IS_ADV_OUT);
} else if (PARS("bcast_rdisc")) {
parm.parm_int_state |= IS_BCAST_RDISC;
} else if (PARS("passive")) {
CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC);
parm.parm_int_state |= IS_NO_RIP | IS_PASSIVE;
} else if (PARSEQ("rdisc_pref")) {
if (parm.parm_rdisc_pref != 0 ||
(parm.parm_rdisc_pref = (int)strtol(buf, &p, 0),
*p != '\0') || (buf == p))
return (bad_str(tgt));
} else if (PARS("pm_rdisc")) {
if (IS_RIP_OUT_OFF(parm.parm_int_state))
return (bad_str(tgt));
parm.parm_int_state |= IS_PM_RDISC;
} else if (PARSEQ("rdisc_interval")) {
if (parm.parm_rdisc_int != 0 ||
(parm.parm_rdisc_int = (int)strtoul(buf, &p, 0),
*p != '\0') || (buf == p) ||
parm.parm_rdisc_int < MIN_MAXADVERTISEINTERVAL ||
parm.parm_rdisc_int > MAX_MAXADVERTISEINTERVAL)
return (bad_str(tgt));
} else if (PARSEQ("fake_default")) {
if (parm.parm_d_metric != 0 ||
IS_RIP_OUT_OFF(parm.parm_int_state) ||
(parm.parm_d_metric = (int)strtoul(buf, &p, 0),
*p != '\0') || (buf == p) ||
parm.parm_d_metric > HOPCNT_INFINITY-1)
return (bad_str(tgt));
} else if (PARSEQ("trust_gateway")) {
/* look for trust_gateway=x.y.z|net/mask|...) */
p = buf;
if (0 > parse_quote(&p, "|", &delim, buf2,
sizeof (buf2)) || !gethost(buf2, &addr))
return (bad_str(tgt));
tg = rtmalloc(sizeof (*tg),
"parse_parms trust_gateway");
(void) memset(tg, 0, sizeof (*tg));
tg->tgate_addr = addr;
i = 0;
/* The default is to trust all routes. */
while (delim == '|') {
p++;
if (i >= MAX_TGATE_NETS ||
0 > parse_quote(&p, "|", &delim, buf2,
sizeof (buf2)) ||
!getnet(buf2, &tg->tgate_nets[i].net,
&tg->tgate_nets[i].mask) ||
tg->tgate_nets[i].net == RIP_DEFAULT ||
tg->tgate_nets[i].mask == 0) {
free(tg);
return (bad_str(tgt));
}
i++;
}
tg->tgate_next = tgates;
tgates = tg;
parm.parm_int_state |= IS_DISTRUST;
} else if (PARS("redirect_ok")) {
parm.parm_int_state |= IS_REDIRECT_OK;
} else if (PARSEQ("rip_neighbor")) {
if (parm.parm_name[0] == '\0' ||
gethost(buf, &parm.parm_ripout_addr) != 1)
return (bad_str(tgt));
} else {
return (bad_str(tgt)); /* error */
}
}
return (insert_parm(&parm));
#undef PARS
#undef PARSEQ
#undef CKF
}
/*
* Get a password, key ID, and expiration date in the format
* passwd|keyID|year/mon/day@hour:min|year/mon/day@hour:min
* returns NULL or error message
*/
static const char *
get_passwd(char *tgt,
char *val,
struct parm *parmp,
uint16_t type,
boolean_t safe) /* 1=from secure file */
{
static char buf[80];
char *val0, *p, delim;
struct auth k, *ap, *ap2;
int i;
ulong_t l;
if (!safe)
return ("ignore unsafe password");
for (ap = parmp->parm_auth, i = 0; ap->type != RIP_AUTH_NONE;
i++, ap++) {
if (i >= MAX_AUTH_KEYS)
return ("too many passwords");
}
(void) memset(&k, 0, sizeof (k));
k.type = type;
k.end = -1-DAY;
val0 = val;
if (0 > parse_quote(&val, "| ,", &delim,
(char *)k.key, sizeof (k.key)))
return (tgt);
if (delim != '|') {
if (type == RIP_AUTH_MD5)
return ("missing Keyid");
} else {
val0 = ++val;
buf[sizeof (buf)-1] = '\0';
if (0 > parse_quote(&val, "| ,", &delim, buf,
sizeof (buf)) ||
buf[sizeof (buf) - 1] != '\0' ||
(l = strtoul(buf, &p, 0)) > 255 ||
p == buf || *p != '\0') {
(void) snprintf(buf, sizeof (buf),
"bad KeyID \"%.20s\"", val0);
return (buf);
}
for (ap2 = parmp->parm_auth; ap2 < ap; ap2++) {
if (ap2->keyid == l) {
(void) snprintf(buf, sizeof (buf),
"duplicate KeyID \"%.20s\"",
val0);
return (buf);
}
}
k.keyid = (int)l;
if (delim == '|') {
val0 = ++val;
if (NULL != (p = parse_ts(&k.start, &val, val0, &delim,
buf, sizeof (buf))))
return (p);
if (delim != '|')
return ("missing second timestamp");
val0 = ++val;
if (NULL != (p = parse_ts(&k.end, &val, val0, &delim,
buf, sizeof (buf))))
return (p);
if ((ulong_t)k.start > (ulong_t)k.end) {
(void) snprintf(buf, sizeof (buf),
"out of order timestamp %.30s", val0);
return (buf);
}
}
}
if (delim != '\0')
return (tgt);
(void) memmove(ap, &k, sizeof (*ap));
return (NULL);
}
int
main(int argc, char *argv[])
{
#define MAX_RCVBUF 127*1024
#define MIN_RCVBUF 4*1024
int ch, bsize, soc;
char *p, *tmp_ptr, *options, *value, delim;
const char *result;
in_addr_t netaddr, netmask;
int on;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEXT"
#endif /* ! TEXT_DOMAIN */
(void) textdomain(TEXT_DOMAIN);
OMSG.rip_nets[0].n_dst = RIP_DEFAULT;
OMSG.rip_nets[0].n_family = RIP_AF_UNSPEC;
OMSG.rip_nets[0].n_metric = htonl(HOPCNT_INFINITY);
if ((pgmname = argv[0]) == NULL)
pgmname = "rtquery";
while ((ch = getopt(argc, argv, "np1w:r:t:a:")) != -1)
switch (ch) {
case 'n':
not_trace = _B_TRUE;
nflag = _B_TRUE;
break;
case 'p':
not_trace = _B_TRUE;
pflag = _B_TRUE;
break;
case '1':
ripv2 = _B_FALSE;
break;
case 'w':
not_trace = _B_TRUE;
wtime = (int)strtoul(optarg, &p, 0);
if (*p != '\0' || wtime <= 0 || p == optarg)
usage();
break;
case 'r':
not_trace = _B_TRUE;
if (rflag)
usage();
rflag = getnet(optarg, &netaddr, &netmask);
if (rflag) {
OMSG.rip_nets[0].n_dst = htonl(netaddr);
OMSG.rip_nets[0].n_family = RIP_AF_INET;
OMSG.rip_nets[0].n_mask = htonl(netmask);
} else {
struct hostent *hp = gethostbyname(optarg);
if (hp == NULL) {
(void) fprintf(stderr, "%s: %s: %s\n",
pgmname, optarg,
hstrerror(h_errno));
exit(EXIT_FAILURE);
}
(void) memcpy(&OMSG.rip_nets[0].n_dst,
hp->h_addr,
sizeof (OMSG.rip_nets[0].n_dst));
OMSG.rip_nets[0].n_family = RIP_AF_INET;
OMSG.rip_nets[0].n_mask = INADDR_BROADCAST;
rflag = _B_TRUE;
}
break;
case 't':
trace = _B_TRUE;
options = optarg;
while (*options != '\0') {
/* messy complications to make -W -Wall happy */
static char on_str[] = "on";
static char more_str[] = "more";
static char off_str[] = "off";
static char dump_str[] = "dump";
static char *traceopts[] = {
#define TRACE_ON 0
on_str,
#define TRACE_MORE 1
more_str,
#define TRACE_OFF 2
off_str,
#define TRACE_DUMP 3
dump_str,
0
};
result = "";
switch (getsubopt(&options, traceopts,
&value)) {
case TRACE_ON:
OMSG.rip_cmd = RIPCMD_TRACEON;
if (value == NULL ||
strlen(value) > MAXPATHLEN)
usage();
result = value;
break;
case TRACE_MORE:
if (value != NULL)
usage();
OMSG.rip_cmd = RIPCMD_TRACEON;
break;
case TRACE_OFF:
if (value != NULL)
usage();
OMSG.rip_cmd = RIPCMD_TRACEOFF;
break;
case TRACE_DUMP:
if (value != NULL)
usage();
OMSG.rip_cmd = RIPCMD_TRACEON;
result = "dump/../table";
break;
default:
usage();
}
(void) strlcpy((char *)OMSG.rip_tracefile,
result, MAXPATHLEN);
omsg_len += strlen(result) -
sizeof (OMSG.ripun);
}
break;
case 'a':
not_trace = _B_TRUE;
p = strchr(optarg, '=');
if (p == NULL)
usage();
*p++ = '\0';
if (0 == strcasecmp("passwd", optarg))
auth_type = RIP_AUTH_PW;
else if (0 == strcasecmp("md5_passwd", optarg))
auth_type = RIP_AUTH_MD5;
else
usage();
if (0 > parse_quote(&p, "|", &delim,
passwd, sizeof (passwd)))
usage();
if (auth_type == RIP_AUTH_MD5 &&
delim == '|') {
tmp_ptr = p+1;
keyid = strtoul(p+1, &p, 0);
if (keyid > 255 || *p != '\0' ||
p == tmp_ptr)
usage();
} else if (delim != '\0') {
usage();
}
break;
default:
usage();
}
argv += optind;
argc -= optind;
if (not_trace && trace)
usage();
if (argc == 0) {
argc = 1;
argv = default_argv;
}
soc = socket(PF_INET, SOCK_DGRAM, 0);
if (soc < 0) {
perror("rtquery: socket");
exit(EXIT_FAILURE);
}
on = 1;
if (setsockopt(soc, IPPROTO_IP, IP_RECVIF, &on, sizeof (on)))
perror("rtquery: setsockopt IP_RECVIF");
/* be prepared to receive a lot of routes */
for (bsize = MAX_RCVBUF; ; bsize -= 1024) {
if (setsockopt(soc, SOL_SOCKET, SO_RCVBUF,
&bsize, sizeof (bsize)) == 0)
break;
if (bsize <= MIN_RCVBUF) {
perror("rtquery: setsockopt SO_RCVBUF");
break;
}
}
if (trace)
trace_loop(argv, soc);
else
query_loop(argv, argc, soc);
/* NOTREACHED */
return (0);
}
