/* Match pattern "p" against the a virtually-joined string consisting
* of "text" and any strings in array "a". */
static int dowild(const uchar *p, const uchar *text, const uchar*const *a)
{
uchar p_ch;
#ifdef WILD_TEST_ITERATIONS
wildmatch_iteration_count++;
#endif
for ( ; (p_ch = *p) != '\0'; text++, p++) {
int matched, special;
uchar t_ch, prev_ch;
while ((t_ch = *text) == '\0') {
if (*a == NULL) {
if (p_ch != '*')
return ABORT_ALL;
break;
}
text = *a++;
}
if (force_lower_case && ISUPPER(t_ch))
t_ch = tolower(t_ch);
switch (p_ch) {
case '\\':
/* Literal match with following character. Note that the test
* in "default" handles the p[1] == '\0' failure case. */
p_ch = *++p;
/* FALLTHROUGH */
default:
if (t_ch != p_ch)
return FALSE;
continue;
case '?':
/* Match anything but '/'. */
if (t_ch == '/')
return FALSE;
continue;
case '*':
if (*++p == '*') {
while (*++p == '*') {}
special = TRUE;
} else
special = FALSE;
if (*p == '\0') {
/* Trailing "**" matches everything. Trailing "*" matches
* only if there are no more slash characters. */
if (!special) {
do {
if (strchr((char*)text, '/') != NULL)
return FALSE;
} while ((text = *a++) != NULL);
}
return TRUE;
}
while (1) {
if (t_ch == '\0') {
if ((text = *a++) == NULL)
break;
t_ch = *text;
continue;
}
if ((matched = dowild(p, text, a)) != FALSE) {
if (!special || matched != ABORT_TO_STARSTAR)
return matched;
} else if (!special && t_ch == '/')
return ABORT_TO_STARSTAR;
t_ch = *++text;
}
return ABORT_ALL;
case '[':
p_ch = *++p;
#ifdef NEGATE_CLASS2
if (p_ch == NEGATE_CLASS2)
p_ch = NEGATE_CLASS;
#endif
/* Assign literal TRUE/FALSE because of "matched" comparison. */
special = p_ch == NEGATE_CLASS? TRUE : FALSE;
if (special) {
/* Inverted character class. */
p_ch = *++p;
}
prev_ch = 0;
matched = FALSE;
do {
if (!p_ch)
return ABORT_ALL;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return ABORT_ALL;
if (t_ch == p_ch)
matched = TRUE;
} else if (p_ch == '-' && prev_ch && p[1] && p[1] != ']') {
p_ch = *++p;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return ABORT_ALL;
}
if (t_ch <= p_ch && t_ch >= prev_ch)
matched = TRUE;
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (p_ch == '[' && p[1] == ':') {
const uchar *s;
int i;
for (s = p += 2; (p_ch = *p) && p_ch != ']'; p++) {}
if (!p_ch)
return ABORT_ALL;
i = p - s - 1;
if (i < 0 || p[-1] != ':') {
/* Didn't find ":]", so treat like a normal set. */
p = s - 2;
p_ch = '[';
if (t_ch == p_ch)
matched = TRUE;
continue;
}
if (CC_EQ(s,i, "alnum")) {
if (ISALNUM(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "alpha")) {
if (ISALPHA(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "blank")) {
if (ISBLANK(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "cntrl")) {
if (ISCNTRL(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "digit")) {
if (ISDIGIT(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "graph")) {
if (ISGRAPH(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "lower")) {
if (ISLOWER(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "print")) {
if (ISPRINT(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "punct")) {
if (ISPUNCT(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "space")) {
if (ISSPACE(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "upper")) {
if (ISUPPER(t_ch))
matched = TRUE;
} else if (CC_EQ(s,i, "xdigit")) {
if (ISXDIGIT(t_ch))
matched = TRUE;
} else /* malformed [:class:] string */
return ABORT_ALL;
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (t_ch == p_ch)
matched = TRUE;
} while (prev_ch = p_ch, (p_ch = *++p) != ']');
if (matched == special || t_ch == '/')
return FALSE;
continue;
}
}
do {
if (*text)
return FALSE;
} while ((text = *a++) != NULL);
return TRUE;
}
/*
* bword --
* Move backward by words.
*/
static int
bword(SCR *sp, VICMD *vp, enum which type)
{
enum { INWORD, NOTWORD } state;
VCS cs;
u_long cnt;
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = vp->m_start.cno;
if (cs_init(sp, &cs))
return (1);
/*
* !!!
* If in whitespace, or the previous character is whitespace, move
* past it. (This doesn't count as a word move.) Stay at the
* character before the current one, it sets word "state" for the
* 'b' command.
*/
if (cs.cs_flags == 0 && !ISBLANK(cs.cs_ch)) {
if (cs_prev(sp, &cs))
return (1);
if (cs.cs_flags == 0 && !ISBLANK(cs.cs_ch))
goto start;
}
if (cs_bblank(sp, &cs))
return (1);
/*
* Cyclically move to the beginning of the previous word -- this
* involves skipping over word characters and then any trailing
* non-word characters. Note, for the 'b' command, the definition
* of a word keeps switching.
*/
start: if (type == BIGWORD)
while (cnt--) {
for (;;) {
if (cs_prev(sp, &cs))
return (1);
if (cs.cs_flags == CS_SOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
}
/*
* When we reach the end of the word before the last
* word, we're done. If we changed state, move forward
* one to the end of the next word.
*/
if (cnt == 0) {
if (cs.cs_flags == 0 && cs_next(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs_bblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_SOF)
goto ret;
}
else
while (cnt--) {
state = cs.cs_flags == 0 &&
inword(cs.cs_ch) ? INWORD : NOTWORD;
for (;;) {
if (cs_prev(sp, &cs))
return (1);
if (cs.cs_flags == CS_SOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
if (state == INWORD) {
if (!inword(cs.cs_ch))
break;
} else
if (inword(cs.cs_ch))
break;
}
/* See comment above. */
if (cnt == 0) {
if (cs.cs_flags == 0 && cs_next(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
if (cs_bblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_SOF)
goto ret;
}
/* If we didn't move, we must be at SOF. */
ret: if (cs.cs_lno == vp->m_start.lno && cs.cs_cno == vp->m_start.cno) {
v_sof(sp, &vp->m_start);
return (1);
}
/* Set the end of the range for motion commands. */
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
/*
* All commands move to the end of the range. Motion commands
* adjust the starting point to the character before the current
* one.
*
* !!!
* The historic vi didn't get this right -- the `yb' command yanked
* the right stuff and even updated the cursor value, but the cursor
* was not actually updated on the screen.
*/
vp->m_final = vp->m_stop;
if (ISMOTION(vp))
--vp->m_start.cno;
return (0);
}
static debug_command*
parse_command(mrb_state *mrb, mrdb_state *mrdb, char *buf)
{
debug_command *cmd = NULL;
char *p = buf;
size_t wlen;
/* get word #1 */
mrdb->words[0] = pick_out_word(mrb, &p);
if (!mrdb->words[0]) {
return NULL;
}
mrdb->wcnt = 1;
/* set remain parameter */
for ( ; *p && ISBLANK(*p); p++) ;
if (*p) {
mrdb->words[mrdb->wcnt++] = p;
}
/* check word #1 */
for (cmd=(debug_command*)debug_command_list; cmd->cmd1; cmd++) {
wlen = strlen(mrdb->words[0]);
if (wlen >= cmd->len1 &&
strncmp(mrdb->words[0], cmd->cmd1, wlen) == 0) {
break;
}
}
if (cmd->cmd2) {
if (mrdb->wcnt > 1) {
/* get word #2 */
mrdb->words[1] = pick_out_word(mrb, &p);
if (mrdb->words[1]) {
/* update remain parameter */
for ( ; *p && ISBLANK(*p); p++) ;
if (*p) {
mrdb->words[mrdb->wcnt++] = p;
}
}
}
/* check word #1,#2 */
for ( ; cmd->cmd1; cmd++) {
wlen = strlen(mrdb->words[0]);
if (wlen < cmd->len1 ||
strncmp(mrdb->words[0], cmd->cmd1, wlen)) {
continue;
}
if (!cmd->cmd2) break; /* word #1 only */
if (mrdb->wcnt == 1) continue; /* word #2 not specified */
wlen = strlen(mrdb->words[1]);
if (wlen >= cmd->len2 &&
strncmp(mrdb->words[1], cmd->cmd2, wlen) == 0) {
break; /* word #1 and #2 */
}
}
}
/* divide remain parameters */
if (cmd->cmd1 && cmd->div) {
p = mrdb->words[--mrdb->wcnt];
for ( ; mrdb->wcnt<MAX_COMMAND_WORD; mrdb->wcnt++) {
mrdb->words[mrdb->wcnt] = pick_out_word(mrb, &p);
if (!mrdb->words[mrdb->wcnt]) {
break;
}
}
}
return cmd->cmd1 ? cmd : NULL;
}
static CURLcode glob_range(URLGlob *glob, char **patternp,
size_t *posp, unsigned long *amount,
int globindex)
{
/* processes a range expression with the point behind the opening '['
- char range: e.g. "a-z]", "B-Q]"
- num range: e.g. "0-9]", "17-2000]"
- num range with leading zeros: e.g. "001-999]"
expression is checked for well-formedness and collected until the next ']'
*/
URLPattern *pat;
int rc;
char *pattern = *patternp;
char *c;
pat = &glob->pattern[glob->size];
pat->globindex = globindex;
if(ISALPHA(*pattern)) {
/* character range detected */
char min_c;
char max_c;
char end_c;
unsigned long step = 1;
pat->type = UPTCharRange;
rc = sscanf(pattern, "%c-%c%c", &min_c, &max_c, &end_c);
if(rc == 3) {
if(end_c == ':') {
char *endp;
errno = 0;
step = strtoul(&pattern[4], &endp, 10);
if(errno || &pattern[4] == endp || *endp != ']')
step = 0;
else
pattern = endp + 1;
}
else if(end_c != ']')
/* then this is wrong */
rc = 0;
else
/* end_c == ']' */
pattern += 4;
}
*posp += (pattern - *patternp);
if(rc != 3 || !step || step > (unsigned)INT_MAX ||
(min_c == max_c && step != 1) ||
(min_c != max_c && (min_c > max_c || step > (unsigned)(max_c - min_c) ||
(max_c - min_c) > ('z' - 'a'))))
/* the pattern is not well-formed */
return GLOBERROR("bad range", *posp, CURLE_URL_MALFORMAT);
/* if there was a ":[num]" thing, use that as step or else use 1 */
pat->content.CharRange.step = (int)step;
pat->content.CharRange.ptr_c = pat->content.CharRange.min_c = min_c;
pat->content.CharRange.max_c = max_c;
if(multiply(amount, ((pat->content.CharRange.max_c -
pat->content.CharRange.min_c) /
pat->content.CharRange.step + 1)))
return GLOBERROR("range overflow", *posp, CURLE_URL_MALFORMAT);
}
else if(ISDIGIT(*pattern)) {
/* numeric range detected */
unsigned long min_n;
unsigned long max_n = 0;
unsigned long step_n = 0;
char *endp;
pat->type = UPTNumRange;
pat->content.NumRange.padlength = 0;
if(*pattern == '0') {
/* leading zero specified, count them! */
c = pattern;
while(ISDIGIT(*c)) {
c++;
++pat->content.NumRange.padlength; /* padding length is set for all
instances of this pattern */
}
}
errno = 0;
min_n = strtoul(pattern, &endp, 10);
if(errno || (endp == pattern))
endp = NULL;
else {
if(*endp != '-')
endp = NULL;
else {
pattern = endp + 1;
while(*pattern && ISBLANK(*pattern))
pattern++;
if(!ISDIGIT(*pattern)) {
endp = NULL;
goto fail;
}
errno = 0;
max_n = strtoul(pattern, &endp, 10);
if(errno)
/* overflow */
endp = NULL;
else if(*endp == ':') {
pattern = endp + 1;
errno = 0;
step_n = strtoul(pattern, &endp, 10);
if(errno)
/* over/underflow situation */
endp = NULL;
}
else
step_n = 1;
if(endp && (*endp == ']')) {
pattern = endp + 1;
}
else
endp = NULL;
}
}
fail:
*posp += (pattern - *patternp);
if(!endp || !step_n ||
(min_n == max_n && step_n != 1) ||
(min_n != max_n && (min_n > max_n || step_n > (max_n - min_n))))
/* the pattern is not well-formed */
return GLOBERROR("bad range", *posp, CURLE_URL_MALFORMAT);
/* typecasting to ints are fine here since we make sure above that we
are within 31 bits */
pat->content.NumRange.ptr_n = pat->content.NumRange.min_n = min_n;
pat->content.NumRange.max_n = max_n;
pat->content.NumRange.step = step_n;
if(multiply(amount, ((pat->content.NumRange.max_n -
pat->content.NumRange.min_n) /
pat->content.NumRange.step + 1)))
return GLOBERROR("range overflow", *posp, CURLE_URL_MALFORMAT);
}
else
return GLOBERROR("bad range specification", *posp, CURLE_URL_MALFORMAT);
*patternp = pattern;
return CURLE_OK;
}
/*
* eword --
* Move forward to the end of the word.
*/
static int
eword(SCR *sp, VICMD *vp, enum which type)
{
enum { INWORD, NOTWORD } state;
VCS cs;
u_long cnt;
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = vp->m_start.cno;
if (cs_init(sp, &cs))
return (1);
/*
* !!!
* If in whitespace, or the next character is whitespace, move past
* it. (This doesn't count as a word move.) Stay at the character
* past the current one, it sets word "state" for the 'e' command.
*/
if (cs.cs_flags == 0 && !ISBLANK(cs.cs_ch)) {
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == 0 && !ISBLANK(cs.cs_ch))
goto start;
}
if (cs_fblank(sp, &cs))
return (1);
/*
* Cyclically move to the next word -- this involves skipping
* over word characters and then any trailing non-word characters.
* Note, for the 'e' command, the definition of a word keeps
* switching.
*/
start: if (type == BIGWORD)
while (cnt--) {
for (;;) {
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
}
/*
* When we reach the start of the word after the last
* word, we're done. If we changed state, back up one
* to the end of the previous word.
*/
if (cnt == 0) {
if (cs.cs_flags == 0 && cs_prev(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
else
while (cnt--) {
state = cs.cs_flags == 0 &&
inword(cs.cs_ch) ? INWORD : NOTWORD;
for (;;) {
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
if (state == INWORD) {
if (!inword(cs.cs_ch))
break;
} else
if (inword(cs.cs_ch))
break;
}
/* See comment above. */
if (cnt == 0) {
if (cs.cs_flags == 0 && cs_prev(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
if (cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
/*
* If we didn't move, we must be at EOF.
*
* !!!
* That's okay for motion commands, however.
*/
ret: if (!ISMOTION(vp) &&
cs.cs_lno == vp->m_start.lno && cs.cs_cno == vp->m_start.cno) {
v_eof(sp, &vp->m_start);
return (1);
}
/* Set the end of the range for motion commands. */
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
/*
* Non-motion commands move to the end of the range.
* Delete and yank stay at the start, ignore others.
*/
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
return (0);
}
/*
* opts_set --
* Change the values of one or more options.
*
* PUBLIC: int opts_set __P((SCR *, ARGS *[], const char *));
*/
int
opts_set(SCR *sp, ARGS **argv, const char *usage)
{
enum optdisp disp;
enum nresult nret;
OPTLIST const *op;
OPTION *spo;
u_long isset, turnoff, value;
int ch, equals, nf, nf2, offset, qmark, rval;
CHAR_T *endp, *name, *p, *sep;
char *p2, *t2;
const char *np;
size_t nlen;
disp = NO_DISPLAY;
for (rval = 0; argv[0]->len != 0; ++argv) {
/*
* The historic vi dumped the options for each occurrence of
* "all" in the set list. Puhleeze.
*/
if (!STRCMP(argv[0]->bp, L("all"))) {
disp = ALL_DISPLAY;
continue;
}
/* Find equals sign or question mark. */
for (sep = NULL, equals = qmark = 0,
p = name = argv[0]->bp; (ch = *p) != '\0'; ++p)
if (ch == '=' || ch == '?') {
if (p == name) {
if (usage != NULL)
msgq(sp, M_ERR,
"032|Usage: %s", usage);
return (1);
}
sep = p;
if (ch == '=')
equals = 1;
else
qmark = 1;
break;
}
turnoff = 0;
op = NULL;
if (sep != NULL)
*sep++ = '\0';
/* Search for the name, then name without any leading "no". */
if ((op = opts_search(name)) == NULL &&
name[0] == L('n') && name[1] == L('o')) {
turnoff = 1;
name += 2;
op = opts_search(name);
}
if (op == NULL) {
opts_nomatch(sp, name);
rval = 1;
continue;
}
/* Find current option values. */
offset = op - optlist;
spo = sp->opts + offset;
/*
* !!!
* Historically, the question mark could be a separate
* argument.
*/
if (!equals && !qmark &&
argv[1]->len == 1 && argv[1]->bp[0] == '?') {
++argv;
qmark = 1;
}
/* Set name, value. */
switch (op->type) {
case OPT_0BOOL:
case OPT_1BOOL:
/* Some options may not be reset. */
if (F_ISSET(op, OPT_NOUNSET) && turnoff) {
msgq_wstr(sp, M_ERR, name,
"291|set: the %s option may not be turned off");
rval = 1;
break;
}
/* Some options may not be set. */
if (F_ISSET(op, OPT_NOSET) && !turnoff) {
msgq_wstr(sp, M_ERR, name,
"313|set: the %s option may never be turned on");
rval = 1;
break;
}
if (equals) {
msgq_wstr(sp, M_ERR, name,
"034|set: [no]%s option doesn't take a value");
rval = 1;
break;
}
if (qmark) {
if (!disp)
disp = SELECT_DISPLAY;
F_SET(spo, OPT_SELECTED);
break;
}
/*
* Do nothing if the value is unchanged, the underlying
* functions can be expensive.
*/
isset = !turnoff;
if (!F_ISSET(op, OPT_ALWAYS)) {
if (isset) {
if (O_ISSET(sp, offset))
break;
} else
if (!O_ISSET(sp, offset))
break;
}
/* Report to subsystems. */
if ((op->func != NULL &&
op->func(sp, spo, NULL, &isset)) ||
ex_optchange(sp, offset, NULL, &isset) ||
v_optchange(sp, offset, NULL, &isset) ||
sp->gp->scr_optchange(sp, offset, NULL, &isset)) {
rval = 1;
break;
}
/* Set the value. */
if (isset)
O_SET(sp, offset);
else
O_CLR(sp, offset);
break;
case OPT_NUM:
if (turnoff) {
msgq_wstr(sp, M_ERR, name,
"035|set: %s option isn't a boolean");
rval = 1;
break;
}
if (qmark || !equals) {
if (!disp)
disp = SELECT_DISPLAY;
F_SET(spo, OPT_SELECTED);
break;
}
if (!ISDIGIT((UCHAR_T)sep[0]))
goto badnum;
if ((nret =
nget_uslong(sp, &value, sep, &endp, 10)) != NUM_OK) {
INT2CHAR(sp, name, STRLEN(name) + 1,
np, nlen);
p2 = msg_print(sp, np, &nf);
INT2CHAR(sp, sep, STRLEN(sep) + 1,
np, nlen);
t2 = msg_print(sp, np, &nf2);
switch (nret) {
case NUM_ERR:
msgq(sp, M_SYSERR,
"036|set: %s option: %s", p2, t2);
break;
case NUM_OVER:
msgq(sp, M_ERR,
"037|set: %s option: %s: value overflow", p2, t2);
break;
case NUM_OK:
case NUM_UNDER:
abort();
}
if (nf)
FREE_SPACE(sp, p2, 0);
if (nf2)
FREE_SPACE(sp, t2, 0);
rval = 1;
break;
}
if (*endp && !ISBLANK(*endp)) {
badnum: INT2CHAR(sp, name, STRLEN(name) + 1,
np, nlen);
p2 = msg_print(sp, np, &nf);
INT2CHAR(sp, sep, STRLEN(sep) + 1,
np, nlen);
t2 = msg_print(sp, np, &nf2);
msgq(sp, M_ERR,
"038|set: %s option: %s is an illegal number", p2, t2);
if (nf)
FREE_SPACE(sp, p2, 0);
if (nf2)
FREE_SPACE(sp, t2, 0);
rval = 1;
break;
}
/* Some options may never be set to zero. */
if (F_ISSET(op, OPT_NOZERO) && value == 0) {
msgq_wstr(sp, M_ERR, name,
"314|set: the %s option may never be set to 0");
rval = 1;
break;
}
/*
* Do nothing if the value is unchanged, the underlying
* functions can be expensive.
*/
if (!F_ISSET(op, OPT_ALWAYS) &&
O_VAL(sp, offset) == value)
break;
/* Report to subsystems. */
INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen);
if ((op->func != NULL &&
op->func(sp, spo, np, &value)) ||
ex_optchange(sp, offset, np, &value) ||
v_optchange(sp, offset, np, &value) ||
sp->gp->scr_optchange(sp, offset, np, &value)) {
rval = 1;
break;
}
/* Set the value. */
if (o_set(sp, offset, 0, NULL, value))
rval = 1;
break;
case OPT_STR:
if (turnoff) {
msgq_wstr(sp, M_ERR, name,
"039|set: %s option isn't a boolean");
rval = 1;
break;
}
if (qmark || !equals) {
if (!disp)
disp = SELECT_DISPLAY;
F_SET(spo, OPT_SELECTED);
break;
}
/* Check for strings that must have even length */
if (F_ISSET(op, OPT_PAIRS) && STRLEN(sep) & 1) {
msgq_wstr(sp, M_ERR, name,
"047|set: the %s option must be in two character groups");
rval = 1;
break;
}
/*
* Do nothing if the value is unchanged, the underlying
* functions can be expensive.
*/
INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen);
if (!F_ISSET(op, OPT_ALWAYS) &&
O_STR(sp, offset) != NULL &&
!strcmp(O_STR(sp, offset), np))
break;
/* Report to subsystems. */
if ((op->func != NULL &&
op->func(sp, spo, np, NULL)) ||
ex_optchange(sp, offset, np, NULL) ||
v_optchange(sp, offset, np, NULL) ||
sp->gp->scr_optchange(sp, offset, np, NULL)) {
rval = 1;
break;
}
/* Set the value. */
if (o_set(sp, offset, OS_STRDUP, np, 0))
rval = 1;
break;
default:
abort();
}
}
if (disp != NO_DISPLAY)
opts_dump(sp, disp);
return (rval);
}
/*****************************************************************************
*
* Curl_cookie_init()
*
* Inits a cookie struct to read data from a local file. This is always
* called before any cookies are set. File may be NULL.
*
* If 'newsession' is TRUE, discard all "session cookies" on read from file.
*
****************************************************************************/
struct CookieInfo *Curl_cookie_init(struct SessionHandle *data,
const char *file,
struct CookieInfo *inc,
bool newsession)
{
struct CookieInfo *c;
FILE *fp;
bool fromfile=TRUE;
if(NULL == inc) {
/* we didn't get a struct, create one */
c = calloc(1, sizeof(struct CookieInfo));
if(!c)
return NULL; /* failed to get memory */
c->filename = strdup(file?file:"none"); /* copy the name just in case */
}
else {
/* we got an already existing one, use that */
c = inc;
}
c->running = FALSE; /* this is not running, this is init */
if(file && strequal(file, "-")) {
fp = stdin;
fromfile=FALSE;
}
else if(file && !*file) {
/* points to a "" string */
fp = NULL;
}
else
fp = file?fopen(file, "r"):NULL;
c->newsession = newsession; /* new session? */
if(fp) {
char *lineptr;
bool headerline;
char *line = malloc(MAX_COOKIE_LINE);
if(line) {
while(fgets(line, MAX_COOKIE_LINE, fp)) {
if(checkprefix("Set-Cookie:", line)) {
/* This is a cookie line, get it! */
lineptr=&line[11];
headerline=TRUE;
}
else {
lineptr=line;
headerline=FALSE;
}
while(*lineptr && ISBLANK(*lineptr))
lineptr++;
Curl_cookie_add(data, c, headerline, lineptr, NULL, NULL);
}
free(line); /* free the line buffer */
}
if(fromfile)
fclose(fp);
}
c->running = TRUE; /* now, we're running */
return c;
}
void palIntin( const char * string, int *nstrt,
long *ireslt, int *jflag ) {
const char *strstart = NULL; /* Pointer to start of search */
const char * ctemp = NULL; /* Pointer into string */
char * endptr = NULL;/* Pointer to string after number */
int retval; /* Return value from strtol */
int hasminus; /* is this a -0 */
/* strtol man page indicates that we should reset errno before
calling strtod */
errno = 0;
/* Locate the start postion */
strstart = &(string[*nstrt-1]);
/* We have to be able to deal with -0 so we have to search the
string first and look for the negative */
hasminus = 0;
ctemp = strstart;
while ( ctemp != '\0' ) {
if (isdigit(*ctemp)) break;
/* Reset so that - 12345 is not a negative number */
hasminus = 0;
/* Flag that we have found a minus */
if (*ctemp == '-') hasminus = 1;
ctemp++;
}
/* Look for the number using the system call, offsetting using
1-based counter. */
retval = strtol( strstart, &endptr, 10 );
if (retval == 0.0 && endptr == strstart) {
/* conversion did not find anything */
*jflag = 1;
/* but SLA compatibility requires that we step
through to remove leading spaces. We also step
through alphabetic characters since they can never
be numbers. Skip past a "+" since it doesn't gain
us anything and matches slalib. */
while (ISBLANK(*endptr) || isalpha(*endptr) || *endptr == '+' ) {
endptr++;
}
} else if ( errno == ERANGE ) {
*jflag = 2;
} else {
if ( retval < 0 || hasminus ) {
*jflag = -1;
} else {
*jflag = 0;
}
}
/* Sort out the position for the next index */
*nstrt = endptr - string + 1;
/* Skip a comma */
if (*endptr == ',') {
(*nstrt)++;
} else {
/* jump past any leading spaces for the next part of the string */
ctemp = endptr;
while ( ISBLANK(*ctemp) ) {
(*nstrt)++;
ctemp++;
}
}
/* And the result unless we found nothing */
if (*jflag != 1) *ireslt = retval;
}
static int
internal_function
internal_fnmatch (const char *pattern, const char *string, int no_leading_period, int flags)
{
register const char *p = pattern, *n = string;
register unsigned char c;
/* Note that this evaluates C many times. */
# ifdef _LIBC
# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
# else
# define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
# endif
while ((c = *p++) != '\0')
{
c = FOLD (c);
switch (c)
{
case '?':
if (*n == '\0')
return FNM_NOMATCH;
else if (*n == '/' && (flags & FNM_FILE_NAME))
return FNM_NOMATCH;
else if (*n == '.' && no_leading_period
&& (n == string
|| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
return FNM_NOMATCH;
break;
case '\\':
if (!(flags & FNM_NOESCAPE))
{
c = *p++;
if (c == '\0')
/* Trailing \ loses. */
return FNM_NOMATCH;
c = FOLD (c);
}
if (FOLD ((unsigned char) *n) != c)
return FNM_NOMATCH;
break;
case '*':
if (*n == '.' && no_leading_period
&& (n == string
|| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
return FNM_NOMATCH;
for (c = *p++; c == '?' || c == '*'; c = *p++)
{
if (*n == '/' && (flags & FNM_FILE_NAME))
/* A slash does not match a wildcard under FNM_FILE_NAME. */
return FNM_NOMATCH;
else if (c == '?')
{
/* A ? needs to match one character. */
if (*n == '\0')
/* There isn't another character; no match. */
return FNM_NOMATCH;
else
/* One character of the string is consumed in matching
this ? wildcard, so *??? won't match if there are
less than three characters. */
++n;
}
}
if (c == '\0')
/* The wildcard(s) is/are the last element of the pattern.
If the name is a file name and contains another slash
this does mean it cannot match. */
return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
? FNM_NOMATCH : 0);
else
{
const char *endp;
endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');
if (c == '[')
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
for (--p; n < endp; ++n)
if (internal_fnmatch (p, n,
(no_leading_period
&& (n == string
|| (n[-1] == '/'
&& (flags
& FNM_FILE_NAME)))),
flags2)
== 0)
return 0;
}
else if (c == '/' && (flags & FNM_FILE_NAME))
{
while (*n != '\0' && *n != '/')
++n;
if (*n == '/'
&& (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
flags) == 0))
return 0;
}
else
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
if (c == '\\' && !(flags & FNM_NOESCAPE))
c = *p;
c = FOLD (c);
for (--p; n < endp; ++n)
if (FOLD ((unsigned char) *n) == c
&& (internal_fnmatch (p, n,
(no_leading_period
&& (n == string
|| (n[-1] == '/'
&& (flags
& FNM_FILE_NAME)))),
flags2) == 0))
return 0;
}
}
/* If we come here no match is possible with the wildcard. */
return FNM_NOMATCH;
case '[':
{
/* Nonzero if the sense of the character class is inverted. */
static int posixly_correct;
register int not;
char cold;
if (posixly_correct == 0)
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
if (*n == '\0')
return FNM_NOMATCH;
if (*n == '.' && no_leading_period && (n == string
|| (n[-1] == '/'
&& (flags
& FNM_FILE_NAME))))
return FNM_NOMATCH;
if (*n == '/' && (flags & FNM_FILE_NAME))
/* `/' cannot be matched. */
return FNM_NOMATCH;
not = (*p == '!' || (posixly_correct < 0 && *p == '^'));
if (not)
++p;
c = *p++;
for (;;)
{
unsigned char fn = FOLD ((unsigned char) *n);
if (!(flags & FNM_NOESCAPE) && c == '\\')
{
if (*p == '\0')
return FNM_NOMATCH;
c = FOLD ((unsigned char) *p);
++p;
if (c == fn)
goto matched;
}
else if (c == '[' && *p == ':')
{
/* Leave room for the null. */
char str[CHAR_CLASS_MAX_LENGTH + 1];
size_t c1 = 0;
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
wctype_t wt;
# endif
const char *startp = p;
for (;;)
{
if (c1 > CHAR_CLASS_MAX_LENGTH)
/* The name is too long and therefore the pattern
is ill-formed. */
return FNM_NOMATCH;
c = *++p;
if (c == ':' && p[1] == ']')
{
p += 2;
break;
}
if (c < 'a' || c >= 'z')
{
/* This cannot possibly be a character class name.
Match it as a normal range. */
p = startp;
c = '[';
goto normal_bracket;
}
str[c1++] = c;
}
str[c1] = '\0';
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
wt = IS_CHAR_CLASS (str);
if (wt == 0)
/* Invalid character class name. */
return FNM_NOMATCH;
if (__iswctype (__btowc ((unsigned char) *n), wt))
goto matched;
# else
if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
|| (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
|| (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
|| (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
|| (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
|| (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
|| (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
|| (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
|| (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
|| (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
|| (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
|| (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
goto matched;
# endif
}
else if (c == '\0')
/* [ (unterminated) loses. */
return FNM_NOMATCH;
else
{
normal_bracket:
if (FOLD (c) == fn)
goto matched;
cold = c;
c = *p++;
if (c == '-' && *p != ']')
{
/* It is a range. */
unsigned char cend = *p++;
if (!(flags & FNM_NOESCAPE) && cend == '\\')
cend = *p++;
if (cend == '\0')
return FNM_NOMATCH;
if (cold <= fn && fn <= FOLD (cend))
goto matched;
c = *p++;
}
}
if (c == ']')
break;
}
if (!not)
return FNM_NOMATCH;
break;
matched:
/* Skip the rest of the [...] that already matched. */
while (c != ']')
{
if (c == '\0')
/* [... (unterminated) loses. */
return FNM_NOMATCH;
c = *p++;
if (!(flags & FNM_NOESCAPE) && c == '\\')
{
if (*p == '\0')
return FNM_NOMATCH;
/* XXX 1003.2d11 is unclear if this is right. */
++p;
}
else if (c == '[' && *p == ':')
{
do
if (*++p == '\0')
return FNM_NOMATCH;
while (*p != ':' || p[1] == ']');
p += 2;
c = *p;
}
}
if (not)
return FNM_NOMATCH;
}
break;
default:
if (c != FOLD ((unsigned char) *n))
return FNM_NOMATCH;
}
++n;
}
if (*n == '\0')
return 0;
if ((flags & FNM_LEADING_DIR) && *n == '/')
/* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
return 0;
return FNM_NOMATCH;
# undef FOLD
}
/*
* v_match -- %
* Search to matching character.
*
* PUBLIC: int v_match __P((SCR *, VICMD *));
*/
int
v_match(SCR *sp, VICMD *vp)
{
VCS cs;
MARK *mp;
size_t cno, len, off;
int cnt, isempty, matchc, startc, (*gc)__P((SCR *, VCS *));
CHAR_T *p;
char *cp;
const char *match_chars;
static MARK match = { 0, 0 };
static int match_dir;
/*
* Historically vi would match (), {} and [] however
* an update included <>. This is ok for editing HTML
* but a pain in the butt for C source.
* Making it an option lets the user decide what is 'right'.
* Also fixed to do something sensible with "".
*/
match_chars = O_STR(sp, O_MATCHCHARS);
/*
* !!!
* Historic practice; ignore the count.
*
* !!!
* Historical practice was to search for the initial character in the
* forward direction only.
*/
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (isempty)
goto nomatch;
return (1);
}
for (off = vp->m_start.cno;; ++off) {
if (off >= len) {
nomatch: msgq(sp, M_BERR, "184|No match character on this line");
return (1);
}
startc = p[off];
cp = strchr(match_chars, startc);
if (cp != NULL)
break;
}
cnt = cp - match_chars;
matchc = match_chars[cnt ^ 1];
/* Alternate back-forward search if startc and matchc the same */
if (startc == matchc) {
/* are we continuing from where last match finished? */
if (match.lno == vp->m_start.lno && match.cno ==vp->m_start.cno)
/* yes - continue in sequence */
match_dir++;
else
/* no - go forward, back, back, forward */
match_dir = 1;
if (match_dir & 2)
cnt++;
}
gc = cnt & 1 ? cs_prev : cs_next;
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = off;
if (cs_init(sp, &cs))
return (1);
for (cnt = 1;;) {
if (gc(sp, &cs))
return (1);
if (cs.cs_flags != 0) {
if (cs.cs_flags == CS_EOF || cs.cs_flags == CS_SOF)
break;
continue;
}
if (cs.cs_ch == matchc && --cnt == 0)
break;
if (cs.cs_ch == startc)
++cnt;
}
if (cnt) {
msgq(sp, M_BERR, "185|Matching character not found");
return (1);
}
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
/*
* If moving right, non-motion commands move to the end of the range.
* Delete and yank stay at the start.
*
* If moving left, all commands move to the end of the range.
*
* !!!
* Don't correct for leftward movement -- historic vi deleted the
* starting cursor position when deleting to a match.
*/
if (vp->m_start.lno < vp->m_stop.lno ||
(vp->m_start.lno == vp->m_stop.lno &&
vp->m_start.cno < vp->m_stop.cno))
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
else
vp->m_final = vp->m_stop;
match.lno = vp->m_final.lno;
match.cno = vp->m_final.cno;
/*
* !!!
* If the motion is across lines, and the earliest cursor position
* is at or before any non-blank characters in the line, i.e. the
* movement is cutting all of the line's text, and the later cursor
* position has nothing other than whitespace characters between it
* and the end of its line, the buffer is in line mode.
*/
if (!ISMOTION(vp) || vp->m_start.lno == vp->m_stop.lno)
return (0);
mp = vp->m_start.lno < vp->m_stop.lno ? &vp->m_start : &vp->m_stop;
if (mp->cno != 0) {
cno = 0;
if (nonblank(sp, mp->lno, &cno))
return (1);
if (cno < mp->cno)
return (0);
}
mp = vp->m_start.lno < vp->m_stop.lno ? &vp->m_stop : &vp->m_start;
if (db_get(sp, mp->lno, DBG_FATAL, &p, &len))
return (1);
for (p += mp->cno + 1, len -= mp->cno; --len; ++p)
if (!ISBLANK((UCHAR_T)*p))
return (0);
F_SET(vp, VM_LMODE);
return (0);
}
/*
* exwr --
* The guts of the ex write commands.
*/
static int
exwr(SCR *sp, EXCMD *cmdp, enum which cmd)
{
MARK rm;
int flags;
char *name;
CHAR_T *p = NULL;
size_t nlen;
const char *n;
int rc;
EX_PRIVATE *exp;
NEEDFILE(sp, cmdp);
/* All write commands can have an associated '!'. */
LF_INIT(FS_POSSIBLE);
if (FL_ISSET(cmdp->iflags, E_C_FORCE))
LF_SET(FS_FORCE);
/* Skip any leading whitespace. */
if (cmdp->argc != 0)
for (p = cmdp->argv[0]->bp; *p != '\0' && ISBLANK((UCHAR_T)*p); ++p);
/* If "write !" it's a pipe to a utility. */
if (cmdp->argc != 0 && cmd == WRITE && *p == '!') {
/* Secure means no shell access. */
if (O_ISSET(sp, O_SECURE)) {
ex_wemsg(sp, cmdp->cmd->name, EXM_SECURE_F);
return (1);
}
/* Expand the argument. */
for (++p; *p && ISBLANK((UCHAR_T)*p); ++p);
if (*p == '\0') {
ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
return (1);
}
if (argv_exp1(sp, cmdp, p, STRLEN(p), 1))
return (1);
/* Set the last bang command */
exp = EXP(sp);
free(exp->lastbcomm);
exp->lastbcomm = v_wstrdup(sp, cmdp->argv[1]->bp,
cmdp->argv[1]->len);
/*
* Historically, vi waited after a write filter even if there
* wasn't any output from the command. People complained when
* nvi waited only if there was output, wanting the visual cue
* that the program hadn't written anything.
*/
F_SET(sp, SC_EX_WAIT_YES);
/*
* !!!
* Ignore the return cursor position, the cursor doesn't
* move.
*/
if (ex_filter(sp, cmdp, &cmdp->addr1,
&cmdp->addr2, &rm, cmdp->argv[1]->bp, FILTER_WRITE))
return (1);
/* Ex terminates with a bang, even if the command fails. */
if (!F_ISSET(sp, SC_VI) && !F_ISSET(sp, SC_EX_SILENT))
(void)ex_puts(sp, "!\n");
return (0);
}
/* Set the FS_ALL flag if we're writing the entire file. */
if (cmdp->addr1.lno <= 1 && !db_exist(sp, cmdp->addr2.lno + 1))
LF_SET(FS_ALL);
/* If "write >>" it's an append to a file. */
if (cmdp->argc != 0 && cmd != XIT && p[0] == '>' && p[1] == '>') {
LF_SET(FS_APPEND);
/* Skip ">>" and whitespace. */
for (p += 2; *p && ISBLANK((UCHAR_T)*p); ++p);
}
/* If no other arguments, just write the file back. */
if (cmdp->argc == 0 || *p == '\0')
return (file_write(sp,
&cmdp->addr1, &cmdp->addr2, NULL, flags));
/* Build an argv so we get an argument count and file expansion. */
if (argv_exp2(sp, cmdp, p, STRLEN(p)))
return (1);
/*
* 0 args: impossible.
* 1 args: impossible (I hope).
* 2 args: read it.
* >2 args: object, too many args.
*
* The 1 args case depends on the argv_sexp() function refusing
* to return success without at least one non-blank character.
*/
switch (cmdp->argc) {
case 0:
case 1:
abort();
/* NOTREACHED */
case 2:
INT2CHAR(sp, cmdp->argv[1]->bp, cmdp->argv[1]->len+1,
n, nlen);
name = v_strdup(sp, n, nlen - 1);
/*
* !!!
* Historically, the read and write commands renamed
* "unnamed" files, or, if the file had a name, set
* the alternate file name.
*/
if (F_ISSET(sp->frp, FR_TMPFILE) &&
!F_ISSET(sp->frp, FR_EXNAMED)) {
char *q;
if ((q = v_strdup(sp, name, nlen - 1)) != NULL) {
free(sp->frp->name);
sp->frp->name = q;
}
/*
* The file has a real name, it's no longer a
* temporary, clear the temporary file flags.
*
* !!!
* If we're writing the whole file, FR_NAMECHANGE
* will be cleared by the write routine -- this is
* historic practice.
*/
F_CLR(sp->frp, FR_TMPEXIT | FR_TMPFILE);
F_SET(sp->frp, FR_NAMECHANGE | FR_EXNAMED);
/* Notify the screen. */
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
} else
set_alt_name(sp, name);
break;
default:
INT2CHAR(sp, p, STRLEN(p) + 1, n, nlen);
ex_emsg(sp, n, EXM_FILECOUNT);
return (1);
}
rc = file_write(sp, &cmdp->addr1, &cmdp->addr2, name, flags);
free(name);
return rc;
}
boolean input_line(FILE * f)
{
int i = EOF;
#ifdef WIN32
if (f != Poptr && fileno (f) != fileno (stdin)) {
long position = ftell (f);
if (position == 0L) { /* Detect and skip Byte order marks. */
int k1 = getc (f);
if (k1 != 0xff && k1 != 0xfe && k1 != 0xef)
rewind (f);
else {
int k2 = getc (f);
if (k2 != 0xff && k2 != 0xfe && k2 != 0xbb)
rewind (f);
else if ((k1 == 0xff && k2 == 0xfe) || /* UTF-16(LE) */
(k1 == 0xfe && k2 == 0xff)) /* UTF-16(BE) */
;
else {
int k3 = getc (f);
if (k1 == 0xef && k2 == 0xbb && k3 == 0xbf) /* UTF-8 */
;
else
rewind (f);
}
}
}
}
#endif
/* Recognize either LF or CR as a line terminator. */
last = first;
while (last < buf_size && (i = getc(f)) != EOF && i != '\n' && i != '\r')
buffer[last++] = (packed_ASCII_code) i;
if (i == EOF && errno != EINTR && last == first)
return false;
/* We didn't get the whole line because our buffer was too small. */
if (i != EOF && i != '\n' && i != '\r') {
fprintf(stderr, "! Unable to read an entire line---bufsize=%u.\n",
(unsigned) buf_size);
fputs("Please increase buf_size in texmf.cnf.\n", stderr);
uexit(1);
}
buffer[last] = ' ';
if (last >= max_buf_stack)
max_buf_stack = last;
/* If next char is LF of a CRLF, read it. */
if (i == '\r') {
while ((i = getc(f)) == EOF && errno == EINTR);
if (i != '\n')
ungetc(i, f);
}
/* Trim trailing whitespace. */
while (last > first && ISBLANK(buffer[last - 1]))
--last;
/* Don't bother using xord if we don't need to. */
return true;
}
/*
* Command text input prompt callback.
*
* For executing a command via the text input prompt. This will
* parse the command value and call the appropriate SARCmd*()
* function.
*/
void SARCmdTextInputCB(const char *value, void *data)
{
char *s;
const char *arg;
Boolean matched_command = False;
unsigned long flags = SAR_CMD_FLAG_VERBOSE |
SAR_CMD_FLAG_ISUSER;
char cmd[SAR_CMD_MAX];
const cmd_ref_struct *cmd_list_ptr, cmd_list[] = SAR_CMD_FUNC_REF_LIST;
void (*cmd_func)(SAR_CMD_PROTOTYPE);
sar_core_struct *core_ptr = SAR_CORE(data);
if((value == NULL) || (core_ptr == NULL))
return;
/* Parse command and value */
/* Get command */
strncpy(cmd, value, sizeof(cmd));
cmd[sizeof(cmd) - 1] = '\0';
s = strchr(cmd, ' ');
if(s == NULL)
s = strchr(cmd, '\t');
if(s != NULL)
*s = '\0';
/* Get argument */
arg = strchr(value, ' ');
if(arg == NULL)
{
arg = "";
}
else
{
while(ISBLANK(*arg))
arg++;
}
/* Iterate through list of SARCmd*() functions to see which
* command matches the command tagent from the value string
*/
for(cmd_list_ptr = cmd_list;
cmd_list_ptr->name != NULL;
cmd_list_ptr++
)
{
const char *cmd_name = cmd_list_ptr->name;
cmd_func = cmd_list_ptr->func;
if(STRISEMPTY(cmd_name) || (cmd_func == NULL))
break;
/* Commands match? */
if(!strcasecmp(cmd_name, cmd))
{
/* Call the function */
cmd_func(core_ptr, arg, flags);
matched_command = True;
break;
}
}
/* Did not match command? */
if(!matched_command)
{
if(SAR_CMD_IS_VERBOSE(flags))
{
char *s = (char *)malloc(
(80 + STRLEN(cmd)) * sizeof(char)
);
sprintf(
s,
"%s: No such command.",
cmd
);
SARMessageAdd(core_ptr->scene, s);
free(s);
}
}
}
struct Cookie *
Curl_cookie_add(struct SessionHandle *data,
/* The 'data' pointer here may be NULL at times, and thus
must only be used very carefully for things that can deal
with data being NULL. Such as infof() and similar */
struct CookieInfo *c,
bool httpheader, /* TRUE if HTTP header-style line */
char *lineptr, /* first character of the line */
const char *domain, /* default domain */
const char *path) /* full path used when this cookie is set,
used to get default path for the cookie
unless set */
{
struct Cookie *clist;
char name[MAX_NAME];
struct Cookie *co;
struct Cookie *lastc=NULL;
time_t now = time(NULL);
bool replace_old = FALSE;
bool badcookie = FALSE; /* cookies are good by default. mmmmm yummy */
#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
/* First, alloc and init a new struct for it */
co = (struct Cookie *)calloc(sizeof(struct Cookie), 1);
if(!co)
return NULL; /* bail out if we're this low on memory */
if(httpheader) {
/* This line was read off a HTTP-header */
const char *ptr;
const char *sep;
const char *semiptr;
char *what;
what = malloc(MAX_COOKIE_LINE);
if(!what) {
free(co);
return NULL;
}
semiptr=strchr(lineptr, ';'); /* first, find a semicolon */
while(*lineptr && ISBLANK(*lineptr))
lineptr++;
ptr = lineptr;
do {
/* we have a <what>=<this> pair or a 'secure' word here */
sep = strchr(ptr, '=');
if(sep && (!semiptr || (semiptr>sep)) ) {
/*
* There is a = sign and if there was a semicolon too, which make sure
* that the semicolon comes _after_ the equal sign.
*/
name[0]=what[0]=0; /* init the buffers */
if(1 <= sscanf(ptr, "%" MAX_NAME_TXT "[^;=]=%"
MAX_COOKIE_LINE_TXT "[^;\r\n]",
name, what)) {
/* this is a <name>=<what> pair */
const char *whatptr;
/* Strip off trailing whitespace from the 'what' */
size_t len=strlen(what);
while(len && ISBLANK(what[len-1])) {
what[len-1]=0;
len--;
}
/* Skip leading whitespace from the 'what' */
whatptr=what;
while(*whatptr && ISBLANK(*whatptr)) {
whatptr++;
}
if(strequal("path", name)) {
co->path=strdup(whatptr);
if(!co->path) {
badcookie = TRUE; /* out of memory bad */
break;
}
}
else if(strequal("domain", name)) {
/* note that this name may or may not have a preceeding dot, but
we don't care about that, we treat the names the same anyway */
const char *domptr=whatptr;
int dotcount=1;
/* Count the dots, we need to make sure that there are enough
of them. */
if('.' == whatptr[0])
/* don't count the initial dot, assume it */
domptr++;
do {
domptr = strchr(domptr, '.');
if(domptr) {
domptr++;
dotcount++;
}
} while(domptr);
/* The original Netscape cookie spec defined that this domain name
MUST have three dots (or two if one of the seven holy TLDs),
but it seems that these kinds of cookies are in use "out there"
so we cannot be that strict. I've therefore lowered the check
to not allow less than two dots. */
if(dotcount < 2) {
/* Received and skipped a cookie with a domain using too few
dots. */
badcookie=TRUE; /* mark this as a bad cookie */
infof(data, "skipped cookie with illegal dotcount domain: %s\n",
whatptr);
}
else {
/* Now, we make sure that our host is within the given domain,
or the given domain is not valid and thus cannot be set. */
if('.' == whatptr[0])
whatptr++; /* ignore preceeding dot */
if(!domain || tailmatch(whatptr, domain)) {
const char *tailptr=whatptr;
if(tailptr[0] == '.')
tailptr++;
co->domain=strdup(tailptr); /* don't prefix w/dots
internally */
if(!co->domain) {
badcookie = TRUE;
break;
}
co->tailmatch=TRUE; /* we always do that if the domain name was
given */
}
else {
/* we did not get a tailmatch and then the attempted set domain
is not a domain to which the current host belongs. Mark as
bad. */
badcookie=TRUE;
infof(data, "skipped cookie with bad tailmatch domain: %s\n",
whatptr);
}
}
}
else if(strequal("version", name)) {
co->version=strdup(whatptr);
if(!co->version) {
badcookie = TRUE;
break;
}
}
else if(strequal("max-age", name)) {
/* Defined in RFC2109:
Optional. The Max-Age attribute defines the lifetime of the
cookie, in seconds. The delta-seconds value is a decimal non-
negative integer. After delta-seconds seconds elapse, the
client should discard the cookie. A value of zero means the
cookie should be discarded immediately.
*/
co->maxage = strdup(whatptr);
if(!co->maxage) {
badcookie = TRUE;
break;
}
co->expires =
atoi((*co->maxage=='\"')?&co->maxage[1]:&co->maxage[0]) + (long)now;
}
else if(strequal("expires", name)) {
co->expirestr=strdup(whatptr);
if(!co->expirestr) {
badcookie = TRUE;
break;
}
co->expires = curl_getdate(what, &now);
}
else if(!co->name) {
co->name = strdup(name);
co->value = strdup(whatptr);
if(!co->name || !co->value) {
badcookie = TRUE;
break;
}
}
/*
else this is the second (or more) name we don't know
about! */
}
else {
/* this is an "illegal" <what>=<this> pair */
}
}
else {
if(sscanf(ptr, "%" MAX_COOKIE_LINE_TXT "[^;\r\n]",
what)) {
if(strequal("secure", what))
co->secure = TRUE;
/* else,
unsupported keyword without assign! */
}
}
if(!semiptr || !*semiptr) {
/* we already know there are no more cookies */
semiptr = NULL;
continue;
}
ptr=semiptr+1;
while(ptr && *ptr && ISBLANK(*ptr))
ptr++;
semiptr=strchr(ptr, ';'); /* now, find the next semicolon */
if(!semiptr && *ptr)
/* There are no more semicolons, but there's a final name=value pair
coming up */
semiptr=strchr(ptr, '\0');
} while(semiptr);
if(!badcookie && !co->domain) {
if(domain) {
/* no domain was given in the header line, set the default */
co->domain=strdup(domain);
if(!co->domain)
badcookie = TRUE;
}
}
if(!badcookie && !co->path && path) {
/* no path was given in the header line, set the default */
char *endslash = strrchr(path, '/');
if(endslash) {
size_t pathlen = endslash-path+1; /* include the ending slash */
co->path=malloc(pathlen+1); /* one extra for the zero byte */
if(co->path) {
memcpy(co->path, path, pathlen);
co->path[pathlen]=0; /* zero terminate */
}
else
badcookie = TRUE;
}
}
free(what);
if(badcookie || !co->name) {
/* we didn't get a cookie name or a bad one,
this is an illegal line, bail out */
freecookie(co);
return NULL;
}
}
else {
/* This line is NOT a HTTP header style line, we do offer support for
reading the odd netscape cookies-file format here */
char *ptr;
char *firstptr;
char *tok_buf;
int fields;
if(lineptr[0]=='#') {
/* don't even try the comments */
free(co);
return NULL;
}
/* strip off the possible end-of-line characters */
ptr=strchr(lineptr, '\r');
if(ptr)
*ptr=0; /* clear it */
ptr=strchr(lineptr, '\n');
if(ptr)
*ptr=0; /* clear it */
firstptr=strtok_r(lineptr, "\t", &tok_buf); /* tokenize it on the TAB */
/* Here's a quick check to eliminate normal HTTP-headers from this */
if(!firstptr || strchr(firstptr, ':')) {
free(co);
return NULL;
}
/* Now loop through the fields and init the struct we already have
allocated */
for(ptr=firstptr, fields=0; ptr && !badcookie;
ptr=strtok_r(NULL, "\t", &tok_buf), fields++) {
switch(fields) {
case 0:
if(ptr[0]=='.') /* skip preceeding dots */
ptr++;
co->domain = strdup(ptr);
if(!co->domain)
badcookie = TRUE;
break;
case 1:
/* This field got its explanation on the 23rd of May 2001 by
Andrés García:
flag: A TRUE/FALSE value indicating if all machines within a given
domain can access the variable. This value is set automatically by
the browser, depending on the value you set for the domain.
As far as I can see, it is set to true when the cookie says
.domain.com and to false when the domain is complete www.domain.com
*/
co->tailmatch=(bool)strequal(ptr, "TRUE"); /* store information */
break;
case 2:
/* It turns out, that sometimes the file format allows the path
field to remain not filled in, we try to detect this and work
around it! Andrés García made us aware of this... */
if (strcmp("TRUE", ptr) && strcmp("FALSE", ptr)) {
/* only if the path doesn't look like a boolean option! */
co->path = strdup(ptr);
if(!co->path)
badcookie = TRUE;
break;
}
/* this doesn't look like a path, make one up! */
co->path = strdup("/");
if(!co->path)
badcookie = TRUE;
fields++; /* add a field and fall down to secure */
/* FALLTHROUGH */
case 3:
co->secure = (bool)strequal(ptr, "TRUE");
break;
case 4:
co->expires = curlx_strtoofft(ptr, NULL, 10);
break;
case 5:
co->name = strdup(ptr);
if(!co->name)
badcookie = TRUE;
break;
case 6:
co->value = strdup(ptr);
if(!co->value)
badcookie = TRUE;
break;
}
}
if(6 == fields) {
/* we got a cookie with blank contents, fix it */
co->value = strdup("");
if(!co->value)
badcookie = TRUE;
else
fields++;
}
if(!badcookie && (7 != fields))
/* we did not find the sufficient number of fields */
badcookie = TRUE;
if(badcookie) {
freecookie(co);
return NULL;
}
}
if(!c->running && /* read from a file */
c->newsession && /* clean session cookies */
!co->expires) { /* this is a session cookie since it doesn't expire! */
freecookie(co);
return NULL;
}
co->livecookie = c->running;
/* now, we have parsed the incoming line, we must now check if this
superceeds an already existing cookie, which it may if the previous have
the same domain and path as this */
clist = c->cookies;
replace_old = FALSE;
while(clist) {
if(strequal(clist->name, co->name)) {
/* the names are identical */
if(clist->domain && co->domain) {
if(strequal(clist->domain, co->domain))
/* The domains are identical */
replace_old=TRUE;
}
else if(!clist->domain && !co->domain)
replace_old = TRUE;
if(replace_old) {
/* the domains were identical */
if(clist->path && co->path) {
if(strequal(clist->path, co->path)) {
replace_old = TRUE;
}
else
replace_old = FALSE;
}
else if(!clist->path && !co->path)
replace_old = TRUE;
else
replace_old = FALSE;
}
if(replace_old && !co->livecookie && clist->livecookie) {
/* Both cookies matched fine, except that the already present
cookie is "live", which means it was set from a header, while
the new one isn't "live" and thus only read from a file. We let
live cookies stay alive */
/* Free the newcomer and get out of here! */
freecookie(co);
return NULL;
}
if(replace_old) {
co->next = clist->next; /* get the next-pointer first */
/* then free all the old pointers */
if(clist->name)
free(clist->name);
if(clist->value)
free(clist->value);
if(clist->domain)
free(clist->domain);
if(clist->path)
free(clist->path);
if(clist->expirestr)
free(clist->expirestr);
if(clist->version)
free(clist->version);
if(clist->maxage)
free(clist->maxage);
*clist = *co; /* then store all the new data */
free(co); /* free the newly alloced memory */
co = clist; /* point to the previous struct instead */
/* We have replaced a cookie, now skip the rest of the list but
make sure the 'lastc' pointer is properly set */
do {
lastc = clist;
clist = clist->next;
} while(clist);
break;
}
}
lastc = clist;
clist = clist->next;
}
if(c->running)
/* Only show this when NOT reading the cookies from a file */
infof(data, "%s cookie %s=\"%s\" for domain %s, path %s, expire %d\n",
replace_old?"Replaced":"Added", co->name, co->value,
co->domain, co->path, co->expires);
if(!replace_old) {
/* then make the last item point on this new one */
if(lastc)
lastc->next = co;
else
c->cookies = co;
}
c->numcookies++; /* one more cookie in the jar */
return co;
}
void TERMWINDOWMEMBER dputWord(const uchar *st, FILE *file)
{
register const uchar *s;
register int newColumn;
if (!OC.Formatting)
{
for (; *st; st++)
{
doChar(*st, file);
}
return;
}
if (prevChar == '\n' && ISBLANK(*st))
{
ddoCR(file);
}
for (newColumn = OC.CrtColumn, s = st; *s; s++)
{
if (*s == '\b')
{
newColumn--;
}
else if (*s == BELL)
{
// beeps do nothing to column
}
else if (*s != TAB)
{
++newColumn;
}
else
{
while (newColumn++ % 8);
}
}
if (!(newColumn > CurrentUser->GetWidth()))
{
if (isspace(*st) && (((newColumn + medium_kludge) >
CurrentUser->GetWidth()) || !medium_kludge))
{
OC.CrtColumn += medium_kludge;
prevChar = *st;
return;
}
}
if (newColumn > CurrentUser->GetWidth())
{
ddoCR(file);
if (isspace(*st))
{
return;
}
}
for (; *st; st++)
{
if (OC.CrtColumn >= CurrentUser->GetWidth())
{
ddoCR(file);
}
doChar(*st, file);
}
}
static int
internal_function
FCT (const CHAR *pattern, const CHAR *string, const CHAR *string_end,
bool no_leading_period, int flags)
{
register const CHAR *p = pattern, *n = string;
register UCHAR c;
#ifdef _LIBC
# if WIDE_CHAR_VERSION
const char *collseq = (const char *)
_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
# else
const UCHAR *collseq = (const UCHAR *)
_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQMB);
# endif
#endif
while ((c = *p++) != L_('\0'))
{
bool new_no_leading_period = false;
c = FOLD (c);
switch (c)
{
case L_('?'):
if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(')
{
int res;
res = EXT (c, p, n, string_end, no_leading_period,
flags);
if (res != -1)
return res;
}
if (n == string_end)
return FNM_NOMATCH;
else if (*n == L_('/') && (flags & FNM_FILE_NAME))
return FNM_NOMATCH;
else if (*n == L_('.') && no_leading_period)
return FNM_NOMATCH;
break;
case L_('\\'):
if (!(flags & FNM_NOESCAPE))
{
c = *p++;
if (c == L_('\0'))
/* Trailing \ loses. */
return FNM_NOMATCH;
c = FOLD (c);
}
if (n == string_end || FOLD ((UCHAR) *n) != c)
return FNM_NOMATCH;
break;
case L_('*'):
if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(')
{
int res;
res = EXT (c, p, n, string_end, no_leading_period,
flags);
if (res != -1)
return res;
}
if (n != string_end && *n == L_('.') && no_leading_period)
return FNM_NOMATCH;
for (c = *p++; c == L_('?') || c == L_('*'); c = *p++)
{
if (*p == L_('(') && (flags & FNM_EXTMATCH) != 0)
{
const CHAR *endp = END (p);
if (endp != p)
{
/* This is a pattern. Skip over it. */
p = endp;
continue;
}
}
if (c == L_('?'))
{
/* A ? needs to match one character. */
if (n == string_end)
/* There isn't another character; no match. */
return FNM_NOMATCH;
else if (*n == L_('/')
&& __builtin_expect (flags & FNM_FILE_NAME, 0))
/* A slash does not match a wildcard under
FNM_FILE_NAME. */
return FNM_NOMATCH;
else
/* One character of the string is consumed in matching
this ? wildcard, so *??? won't match if there are
less than three characters. */
++n;
}
}
if (c == L_('\0'))
/* The wildcard(s) is/are the last element of the pattern.
If the name is a file name and contains another slash
this means it cannot match, unless the FNM_LEADING_DIR
flag is set. */
{
int result = (flags & FNM_FILE_NAME) == 0 ? 0 : FNM_NOMATCH;
if (flags & FNM_FILE_NAME)
{
if (flags & FNM_LEADING_DIR)
result = 0;
else
{
if (MEMCHR (n, L_('/'), string_end - n) == NULL)
result = 0;
}
}
return result;
}
else
{
const CHAR *endp;
endp = MEMCHR (n, (flags & FNM_FILE_NAME) ? L_('/') : L_('\0'),
string_end - n);
if (endp == NULL)
endp = string_end;
if (c == L_('[')
|| (__builtin_expect (flags & FNM_EXTMATCH, 0) != 0
&& (c == L_('@') || c == L_('+') || c == L_('!'))
&& *p == L_('(')))
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
bool no_leading_period2 = no_leading_period;
for (--p; n < endp; ++n, no_leading_period2 = false)
if (FCT (p, n, string_end, no_leading_period2, flags2)
== 0)
return 0;
}
else if (c == L_('/') && (flags & FNM_FILE_NAME))
{
while (n < string_end && *n != L_('/'))
++n;
if (n < string_end && *n == L_('/')
&& (FCT (p, n + 1, string_end, flags & FNM_PERIOD, flags)
== 0))
return 0;
}
else
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
int no_leading_period2 = no_leading_period;
if (c == L_('\\') && !(flags & FNM_NOESCAPE))
c = *p;
c = FOLD (c);
for (--p; n < endp; ++n, no_leading_period2 = false)
if (FOLD ((UCHAR) *n) == c
&& (FCT (p, n, string_end, no_leading_period2, flags2)
== 0))
return 0;
}
}
/* If we come here no match is possible with the wildcard. */
return FNM_NOMATCH;
case L_('['):
{
/* Nonzero if the sense of the character class is inverted. */
register bool not;
CHAR cold;
UCHAR fn;
if (posixly_correct == 0)
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
if (n == string_end)
return FNM_NOMATCH;
if (*n == L_('.') && no_leading_period)
return FNM_NOMATCH;
if (*n == L_('/') && (flags & FNM_FILE_NAME))
/* `/' cannot be matched. */
return FNM_NOMATCH;
not = (*p == L_('!') || (posixly_correct < 0 && *p == L_('^')));
if (not)
++p;
fn = FOLD ((UCHAR) *n);
c = *p++;
for (;;)
{
if (!(flags & FNM_NOESCAPE) && c == L_('\\'))
{
if (*p == L_('\0'))
return FNM_NOMATCH;
c = FOLD ((UCHAR) *p);
++p;
if (c == fn)
goto matched;
}
else if (c == L_('[') && *p == L_(':'))
{
/* Leave room for the null. */
CHAR str[CHAR_CLASS_MAX_LENGTH + 1];
size_t c1 = 0;
#if defined _LIBC || WIDE_CHAR_SUPPORT
wctype_t wt;
#endif
const CHAR *startp = p;
for (;;)
{
if (c1 == CHAR_CLASS_MAX_LENGTH)
/* The name is too long and therefore the pattern
is ill-formed. */
return FNM_NOMATCH;
c = *++p;
if (c == L_(':') && p[1] == L_(']'))
{
p += 2;
break;
}
if (c < L_('a') || c >= L_('z'))
{
/* This cannot possibly be a character class name.
Match it as a normal range. */
p = startp;
c = L_('[');
goto normal_bracket;
}
str[c1++] = c;
}
str[c1] = L_('\0');
#if defined _LIBC || WIDE_CHAR_SUPPORT
wt = IS_CHAR_CLASS (str);
if (wt == 0)
/* Invalid character class name. */
return FNM_NOMATCH;
# if defined _LIBC && ! WIDE_CHAR_VERSION
/* The following code is glibc specific but does
there a good job in speeding up the code since
we can avoid the btowc() call. */
if (_ISCTYPE ((UCHAR) *n, wt))
goto matched;
# else
if (ISWCTYPE (BTOWC ((UCHAR) *n), wt))
goto matched;
# endif
#else
if ((STREQ (str, L_("alnum")) && ISALNUM ((UCHAR) *n))
|| (STREQ (str, L_("alpha")) && ISALPHA ((UCHAR) *n))
|| (STREQ (str, L_("blank")) && ISBLANK ((UCHAR) *n))
|| (STREQ (str, L_("cntrl")) && ISCNTRL ((UCHAR) *n))
|| (STREQ (str, L_("digit")) && ISDIGIT ((UCHAR) *n))
|| (STREQ (str, L_("graph")) && ISGRAPH ((UCHAR) *n))
|| (STREQ (str, L_("lower")) && ISLOWER ((UCHAR) *n))
|| (STREQ (str, L_("print")) && ISPRINT ((UCHAR) *n))
|| (STREQ (str, L_("punct")) && ISPUNCT ((UCHAR) *n))
|| (STREQ (str, L_("space")) && ISSPACE ((UCHAR) *n))
|| (STREQ (str, L_("upper")) && ISUPPER ((UCHAR) *n))
|| (STREQ (str, L_("xdigit")) && ISXDIGIT ((UCHAR) *n)))
goto matched;
#endif
c = *p++;
}
#ifdef _LIBC
else if (c == L_('[') && *p == L_('='))
{
UCHAR str[1];
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
const CHAR *startp = p;
c = *++p;
if (c == L_('\0'))
{
p = startp;
c = L_('[');
goto normal_bracket;
}
str[0] = c;
c = *++p;
if (c != L_('=') || p[1] != L_(']'))
{
p = startp;
c = L_('[');
goto normal_bracket;
}
p += 2;
if (nrules == 0)
{
if ((UCHAR) *n == str[0])
goto matched;
}
else
{
const int32_t *table;
# if WIDE_CHAR_VERSION
const int32_t *weights;
const int32_t *extra;
# else
const unsigned char *weights;
const unsigned char *extra;
# endif
const int32_t *indirect;
int32_t idx;
const UCHAR *cp = (const UCHAR *) str;
/* This #include defines a local function! */
# if WIDE_CHAR_VERSION
# include <locale/weightwc.h>
# else
# include <locale/weight.h>
# endif
# if WIDE_CHAR_VERSION
table = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
weights = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
extra = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
indirect = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
# else
table = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
weights = (const unsigned char *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
indirect = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
# endif
idx = findidx (&cp);
if (idx != 0)
{
/* We found a table entry. Now see whether the
character we are currently at has the same
equivalance class value. */
int len = weights[idx];
int32_t idx2;
const UCHAR *np = (const UCHAR *) n;
idx2 = findidx (&np);
if (idx2 != 0 && len == weights[idx2])
{
int cnt = 0;
while (cnt < len
&& (weights[idx + 1 + cnt]
== weights[idx2 + 1 + cnt]))
++cnt;
if (cnt == len)
goto matched;
}
}
}
c = *p++;
}
#endif
else if (c == L_('\0'))
/* [ (unterminated) loses. */
return FNM_NOMATCH;
else
{
bool is_range = false;
#ifdef _LIBC
bool is_seqval = false;
if (c == L_('[') && *p == L_('.'))
{
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
const CHAR *startp = p;
size_t c1 = 0;
while (1)
{
c = *++p;
if (c == L_('.') && p[1] == L_(']'))
{
p += 2;
break;
}
if (c == '\0')
return FNM_NOMATCH;
++c1;
}
/* We have to handling the symbols differently in
ranges since then the collation sequence is
important. */
is_range = *p == L_('-') && p[1] != L_('\0');
if (nrules == 0)
{
/* There are no names defined in the collation
data. Therefore we only accept the trivial
names consisting of the character itself. */
if (c1 != 1)
return FNM_NOMATCH;
if (!is_range && *n == startp[1])
goto matched;
cold = startp[1];
c = *p++;
}
else
{
int32_t table_size;
const int32_t *symb_table;
# ifdef WIDE_CHAR_VERSION
char str[c1];
size_t strcnt;
# else
# define str (startp + 1)
# endif
const unsigned char *extra;
int32_t idx;
int32_t elem;
int32_t second;
int32_t hash;
# ifdef WIDE_CHAR_VERSION
/* We have to convert the name to a single-byte
string. This is possible since the names
consist of ASCII characters and the internal
representation is UCS4. */
for (strcnt = 0; strcnt < c1; ++strcnt)
str[strcnt] = startp[1 + strcnt];
# endif
table_size =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_SYMB_HASH_SIZEMB);
symb_table = (const int32_t *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_TABLEMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_EXTRAMB);
/* Locate the character in the hashing table. */
hash = elem_hash (str, c1);
idx = 0;
elem = hash % table_size;
second = hash % (table_size - 2);
while (symb_table[2 * elem] != 0)
{
/* First compare the hashing value. */
if (symb_table[2 * elem] == hash
&& c1 == extra[symb_table[2 * elem + 1]]
&& memcmp (str,
&extra[symb_table[2 * elem + 1]
+ 1], c1) == 0)
{
/* Yep, this is the entry. */
idx = symb_table[2 * elem + 1];
idx += 1 + extra[idx];
break;
}
/* Next entry. */
elem += second;
}
if (symb_table[2 * elem] != 0)
{
/* Compare the byte sequence but only if
this is not part of a range. */
# ifdef WIDE_CHAR_VERSION
int32_t *wextra;
idx += 1 + extra[idx];
/* Adjust for the alignment. */
idx = (idx + 3) & ~3;
wextra = (int32_t *) &extra[idx + 4];
# endif
if (! is_range)
{
# ifdef WIDE_CHAR_VERSION
for (c1 = 0;
(int32_t) c1 < wextra[idx];
++c1)
if (n[c1] != wextra[1 + c1])
break;
if ((int32_t) c1 == wextra[idx])
goto matched;
# else
for (c1 = 0; c1 < extra[idx]; ++c1)
if (n[c1] != extra[1 + c1])
break;
if (c1 == extra[idx])
goto matched;
# endif
}
/* Get the collation sequence value. */
is_seqval = true;
# ifdef WIDE_CHAR_VERSION
cold = wextra[1 + wextra[idx]];
# else
/* Adjust for the alignment. */
idx += 1 + extra[idx];
idx = (idx + 3) & ~4;
cold = *((int32_t *) &extra[idx]);
# endif
c = *p++;
}
else if (c1 == 1)
{
/* No valid character. Match it as a
single byte. */
if (!is_range && *n == str[0])
goto matched;
cold = str[0];
c = *p++;
}
else
return FNM_NOMATCH;
}
}
else
# undef str
#endif
{
c = FOLD (c);
normal_bracket:
/* We have to handling the symbols differently in
ranges since then the collation sequence is
important. */
is_range = (*p == L_('-') && p[1] != L_('\0')
&& p[1] != L_(']'));
if (!is_range && c == fn)
goto matched;
cold = c;
c = *p++;
}
if (c == L_('-') && *p != L_(']'))
{
#if _LIBC
/* We have to find the collation sequence
value for C. Collation sequence is nothing
we can regularly access. The sequence
value is defined by the order in which the
definitions of the collation values for the
various characters appear in the source
file. A strange concept, nowhere
documented. */
uint32_t fcollseq;
uint32_t lcollseq;
UCHAR cend = *p++;
# ifdef WIDE_CHAR_VERSION
/* Search in the `names' array for the characters. */
fcollseq = __collseq_table_lookup (collseq, fn);
if (fcollseq == ~((uint32_t) 0))
/* XXX We don't know anything about the character
we are supposed to match. This means we are
failing. */
goto range_not_matched;
if (is_seqval)
lcollseq = cold;
else
lcollseq = __collseq_table_lookup (collseq, cold);
# else
fcollseq = collseq[fn];
lcollseq = is_seqval ? cold : collseq[(UCHAR) cold];
# endif
is_seqval = false;
if (cend == L_('[') && *p == L_('.'))
{
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_NRULES);
const CHAR *startp = p;
size_t c1 = 0;
while (1)
{
c = *++p;
if (c == L_('.') && p[1] == L_(']'))
{
p += 2;
break;
}
if (c == '\0')
return FNM_NOMATCH;
++c1;
}
if (nrules == 0)
{
/* There are no names defined in the
collation data. Therefore we only
accept the trivial names consisting
of the character itself. */
if (c1 != 1)
return FNM_NOMATCH;
cend = startp[1];
}
else
{
int32_t table_size;
const int32_t *symb_table;
# ifdef WIDE_CHAR_VERSION
char str[c1];
size_t strcnt;
# else
# define str (startp + 1)
# endif
const unsigned char *extra;
int32_t idx;
int32_t elem;
int32_t second;
int32_t hash;
# ifdef WIDE_CHAR_VERSION
/* We have to convert the name to a single-byte
string. This is possible since the names
consist of ASCII characters and the internal
representation is UCS4. */
for (strcnt = 0; strcnt < c1; ++strcnt)
str[strcnt] = startp[1 + strcnt];
# endif
table_size =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_SYMB_HASH_SIZEMB);
symb_table = (const int32_t *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_TABLEMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_EXTRAMB);
/* Locate the character in the hashing
table. */
hash = elem_hash (str, c1);
idx = 0;
elem = hash % table_size;
second = hash % (table_size - 2);
while (symb_table[2 * elem] != 0)
{
/* First compare the hashing value. */
if (symb_table[2 * elem] == hash
&& (c1
== extra[symb_table[2 * elem + 1]])
&& memcmp (str,
&extra[symb_table[2 * elem + 1]
+ 1], c1) == 0)
{
/* Yep, this is the entry. */
idx = symb_table[2 * elem + 1];
idx += 1 + extra[idx];
break;
}
/* Next entry. */
elem += second;
}
if (symb_table[2 * elem] != 0)
{
/* Compare the byte sequence but only if
this is not part of a range. */
# ifdef WIDE_CHAR_VERSION
int32_t *wextra;
idx += 1 + extra[idx];
/* Adjust for the alignment. */
idx = (idx + 3) & ~4;
wextra = (int32_t *) &extra[idx + 4];
# endif
/* Get the collation sequence value. */
is_seqval = true;
# ifdef WIDE_CHAR_VERSION
cend = wextra[1 + wextra[idx]];
# else
/* Adjust for the alignment. */
idx += 1 + extra[idx];
idx = (idx + 3) & ~4;
cend = *((int32_t *) &extra[idx]);
# endif
}
else if (symb_table[2 * elem] != 0 && c1 == 1)
{
cend = str[0];
c = *p++;
}
else
return FNM_NOMATCH;
}
# undef str
}
else
{
if (!(flags & FNM_NOESCAPE) && cend == L_('\\'))
cend = *p++;
if (cend == L_('\0'))
return FNM_NOMATCH;
cend = FOLD (cend);
}
/* XXX It is not entirely clear to me how to handle
characters which are not mentioned in the
collation specification. */
if (
# ifdef WIDE_CHAR_VERSION
lcollseq == 0xffffffff ||
# endif
lcollseq <= fcollseq)
{
/* We have to look at the upper bound. */
uint32_t hcollseq;
if (is_seqval)
hcollseq = cend;
else
{
# ifdef WIDE_CHAR_VERSION
hcollseq =
__collseq_table_lookup (collseq, cend);
if (hcollseq == ~((uint32_t) 0))
{
/* Hum, no information about the upper
bound. The matching succeeds if the
lower bound is matched exactly. */
if (lcollseq != fcollseq)
goto range_not_matched;
goto matched;
}
# else
hcollseq = collseq[cend];
# endif
}
if (lcollseq <= hcollseq && fcollseq <= hcollseq)
goto matched;
}
# ifdef WIDE_CHAR_VERSION
range_not_matched:
# endif
#else
/* We use a boring value comparison of the character
values. This is better than comparing using
`strcoll' since the latter would have surprising
and sometimes fatal consequences. */
UCHAR cend = *p++;
if (!(flags & FNM_NOESCAPE) && cend == L_('\\'))
cend = *p++;
if (cend == L_('\0'))
return FNM_NOMATCH;
/* It is a range. */
if (cold <= fn && fn <= cend)
goto matched;
#endif
c = *p++;
}
}
if (c == L_(']'))
break;
}
if (!not)
return FNM_NOMATCH;
break;
matched:
/* Skip the rest of the [...] that already matched. */
do
{
ignore_next:
c = *p++;
if (c == L_('\0'))
/* [... (unterminated) loses. */
return FNM_NOMATCH;
if (!(flags & FNM_NOESCAPE) && c == L_('\\'))
{
if (*p == L_('\0'))
return FNM_NOMATCH;
/* XXX 1003.2d11 is unclear if this is right. */
++p;
}
else if (c == L_('[') && *p == L_(':'))
{
int c1 = 0;
const CHAR *startp = p;
while (1)
{
c = *++p;
if (++c1 == CHAR_CLASS_MAX_LENGTH)
return FNM_NOMATCH;
if (*p == L_(':') && p[1] == L_(']'))
break;
if (c < L_('a') || c >= L_('z'))
{
p = startp;
goto ignore_next;
}
}
p += 2;
c = *p++;
}
else if (c == L_('[') && *p == L_('='))
{
c = *++p;
if (c == L_('\0'))
return FNM_NOMATCH;
c = *++p;
if (c != L_('=') || p[1] != L_(']'))
return FNM_NOMATCH;
p += 2;
c = *p++;
}
else if (c == L_('[') && *p == L_('.'))
{
++p;
while (1)
{
c = *++p;
if (c == '\0')
return FNM_NOMATCH;
if (*p == L_('.') && p[1] == L_(']'))
break;
}
p += 2;
c = *p++;
}
}
while (c != L_(']'));
if (not)
return FNM_NOMATCH;
}
break;
case L_('+'):
case L_('@'):
case L_('!'):
if (__builtin_expect (flags & FNM_EXTMATCH, 0) && *p == '(')
{
int res;
res = EXT (c, p, n, string_end, no_leading_period, flags);
if (res != -1)
return res;
}
goto normal_match;
case L_('/'):
if (NO_LEADING_PERIOD (flags))
{
if (n == string_end || c != (UCHAR) *n)
return FNM_NOMATCH;
new_no_leading_period = true;
break;
}
/* FALLTHROUGH */
default:
normal_match:
if (n == string_end || c != FOLD ((UCHAR) *n))
return FNM_NOMATCH;
}
no_leading_period = new_no_leading_period;
++n;
}
if (n == string_end)
return 0;
if ((flags & FNM_LEADING_DIR) && n != string_end && *n == L_('/'))
/* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
return 0;
return FNM_NOMATCH;
}
/*****************************************************************************
*
* Curl_cookie_init()
*
* Inits a cookie struct to read data from a local file. This is always
* called before any cookies are set. File may be NULL.
*
* If 'newsession' is TRUE, discard all "session cookies" on read from file.
*
* Returns NULL on out of memory. Invalid cookies are ignored.
****************************************************************************/
struct CookieInfo *Curl_cookie_init(struct Curl_easy *data,
const char *file,
struct CookieInfo *inc,
bool newsession)
{
struct CookieInfo *c;
FILE *fp = NULL;
bool fromfile = TRUE;
char *line = NULL;
if(NULL == inc) {
/* we didn't get a struct, create one */
c = calloc(1, sizeof(struct CookieInfo));
if(!c)
return NULL; /* failed to get memory */
c->filename = strdup(file?file:"none"); /* copy the name just in case */
if(!c->filename)
goto fail; /* failed to get memory */
}
else {
/* we got an already existing one, use that */
c = inc;
}
c->running = FALSE; /* this is not running, this is init */
if(file && !strcmp(file, "-")) {
fp = stdin;
fromfile = FALSE;
}
else if(file && !*file) {
/* points to a "" string */
fp = NULL;
}
else
fp = file?fopen(file, FOPEN_READTEXT):NULL;
c->newsession = newsession; /* new session? */
if(fp) {
char *lineptr;
bool headerline;
line = malloc(MAX_COOKIE_LINE);
if(!line)
goto fail;
while(get_line(line, MAX_COOKIE_LINE, fp)) {
if(checkprefix("Set-Cookie:", line)) {
/* This is a cookie line, get it! */
lineptr = &line[11];
headerline = TRUE;
}
else {
lineptr = line;
headerline = FALSE;
}
while(*lineptr && ISBLANK(*lineptr))
lineptr++;
Curl_cookie_add(data, c, headerline, TRUE, lineptr, NULL, NULL);
}
free(line); /* free the line buffer */
remove_expired(c); /* run this once, not on every cookie */
if(fromfile)
fclose(fp);
}
c->running = TRUE; /* now, we're running */
return c;
fail:
free(line);
if(!inc)
/* Only clean up if we allocated it here, as the original could still be in
* use by a share handle */
Curl_cookie_cleanup(c);
if(fromfile && fp)
fclose(fp);
return NULL; /* out of memory */
}
static int loop(const unsigned char *pattern, const unsigned char *string)
{
loop_state state = CURLFNM_LOOP_DEFAULT;
unsigned char *p = (unsigned char *)pattern;
unsigned char *s = (unsigned char *)string;
unsigned char charset[CURLFNM_CHSET_SIZE] = { 0 };
int rc = 0;
for(;;) {
switch(state) {
case CURLFNM_LOOP_DEFAULT:
if(*p == '*') {
while(*(p+1) == '*') /* eliminate multiple stars */
p++;
if(*s == '\0' && *(p+1) == '\0')
return CURL_FNMATCH_MATCH;
rc = loop(p + 1, s); /* *.txt matches .txt <=> .txt matches .txt */
if(rc == CURL_FNMATCH_MATCH)
return CURL_FNMATCH_MATCH;
if(*s) /* let the star eat up one character */
s++;
else
return CURL_FNMATCH_NOMATCH;
}
else if(*p == '?') {
if(ISPRINT(*s)) {
s++;
p++;
}
else if(*s == '\0')
return CURL_FNMATCH_NOMATCH;
else
return CURL_FNMATCH_FAIL; /* cannot deal with other character */
}
else if(*p == '\0') {
if(*s == '\0')
return CURL_FNMATCH_MATCH;
else
return CURL_FNMATCH_NOMATCH;
}
else if(*p == '\\') {
state = CURLFNM_LOOP_BACKSLASH;
p++;
}
else if(*p == '[') {
unsigned char *pp = p+1; /* cannot handle with pointer to register */
if(setcharset(&pp, charset)) {
int found = FALSE;
if(charset[(unsigned int)*s])
found = TRUE;
else if(charset[CURLFNM_ALNUM])
found = ISALNUM(*s);
else if(charset[CURLFNM_ALPHA])
found = ISALPHA(*s);
else if(charset[CURLFNM_DIGIT])
found = ISDIGIT(*s);
else if(charset[CURLFNM_XDIGIT])
found = ISXDIGIT(*s);
else if(charset[CURLFNM_PRINT])
found = ISPRINT(*s);
else if(charset[CURLFNM_SPACE])
found = ISSPACE(*s);
else if(charset[CURLFNM_UPPER])
found = ISUPPER(*s);
else if(charset[CURLFNM_LOWER])
found = ISLOWER(*s);
else if(charset[CURLFNM_BLANK])
found = ISBLANK(*s);
else if(charset[CURLFNM_GRAPH])
found = ISGRAPH(*s);
if(charset[CURLFNM_NEGATE])
found = !found;
if(found) {
p = pp+1;
s++;
memset(charset, 0, CURLFNM_CHSET_SIZE);
}
else
return CURL_FNMATCH_NOMATCH;
}
else
return CURL_FNMATCH_FAIL;
}
else {
if(*p++ != *s++)
return CURL_FNMATCH_NOMATCH;
}
break;
case CURLFNM_LOOP_BACKSLASH:
if(ISPRINT(*p)) {
if(*p++ == *s++)
state = CURLFNM_LOOP_DEFAULT;
else
return CURL_FNMATCH_NOMATCH;
}
else
return CURL_FNMATCH_FAIL;
break;
}
}
}
struct Cookie *
Curl_cookie_add(struct SessionHandle *data,
/* The 'data' pointer here may be NULL at times, and thus
must only be used very carefully for things that can deal
with data being NULL. Such as infof() and similar */
struct CookieInfo *c,
bool httpheader, /* TRUE if HTTP header-style line */
char *lineptr, /* first character of the line */
const char *domain, /* default domain */
const char *path) /* full path used when this cookie is set,
used to get default path for the cookie
unless set */
{
struct Cookie *clist;
char name[MAX_NAME];
struct Cookie *co;
struct Cookie *lastc=NULL;
time_t now = time(NULL);
bool replace_old = FALSE;
bool badcookie = FALSE; /* cookies are good by default. mmmmm yummy */
#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
/* First, alloc and init a new struct for it */
co = calloc(1, sizeof(struct Cookie));
if(!co)
return NULL; /* bail out if we're this low on memory */
if(httpheader) {
/* This line was read off a HTTP-header */
const char *ptr;
const char *semiptr;
char *what;
what = malloc(MAX_COOKIE_LINE);
if(!what) {
free(co);
return NULL;
}
semiptr=strchr(lineptr, ';'); /* first, find a semicolon */
while(*lineptr && ISBLANK(*lineptr))
lineptr++;
ptr = lineptr;
do {
/* we have a <what>=<this> pair or a stand-alone word here */
name[0]=what[0]=0; /* init the buffers */
if(1 <= sscanf(ptr, "%" MAX_NAME_TXT "[^;\r\n =]=%"
MAX_COOKIE_LINE_TXT "[^;\r\n]",
name, what)) {
/* Use strstore() below to properly deal with received cookie
headers that have the same string property set more than once,
and then we use the last one. */
const char *whatptr;
bool done = FALSE;
bool sep;
size_t len=strlen(what);
const char *endofn = &ptr[ strlen(name) ];
/* skip trailing spaces in name */
while(*endofn && ISBLANK(*endofn))
endofn++;
/* name ends with a '=' ? */
sep = (*endofn == '=')?TRUE:FALSE;
/* Strip off trailing whitespace from the 'what' */
while(len && ISBLANK(what[len-1])) {
what[len-1]=0;
len--;
}
/* Skip leading whitespace from the 'what' */
whatptr=what;
while(*whatptr && ISBLANK(*whatptr))
whatptr++;
if(!len) {
/* this was a "<name>=" with no content, and we must allow
'secure' and 'httponly' specified this weirdly */
done = TRUE;
if(Curl_raw_equal("secure", name))
co->secure = TRUE;
else if(Curl_raw_equal("httponly", name))
co->httponly = TRUE;
else if(sep)
/* there was a '=' so we're not done parsing this field */
done = FALSE;
}
if(done)
;
else if(Curl_raw_equal("path", name)) {
strstore(&co->path, whatptr);
if(!co->path) {
badcookie = TRUE; /* out of memory bad */
break;
}
co->spath = sanitize_cookie_path(co->path);
if(!co->spath) {
badcookie = TRUE; /* out of memory bad */
break;
}
}
else if(Curl_raw_equal("domain", name)) {
/* Now, we make sure that our host is within the given domain,
or the given domain is not valid and thus cannot be set. */
if('.' == whatptr[0])
whatptr++; /* ignore preceding dot */
if(!domain || tailmatch(whatptr, domain)) {
const char *tailptr=whatptr;
if(tailptr[0] == '.')
tailptr++;
strstore(&co->domain, tailptr); /* don't prefix w/dots
internally */
if(!co->domain) {
badcookie = TRUE;
break;
}
co->tailmatch=TRUE; /* we always do that if the domain name was
given */
}
else {
/* we did not get a tailmatch and then the attempted set domain
is not a domain to which the current host belongs. Mark as
bad. */
badcookie=TRUE;
infof(data, "skipped cookie with bad tailmatch domain: %s\n",
whatptr);
}
}
else if(Curl_raw_equal("version", name)) {
strstore(&co->version, whatptr);
if(!co->version) {
badcookie = TRUE;
break;
}
}
else if(Curl_raw_equal("max-age", name)) {
/* Defined in RFC2109:
Optional. The Max-Age attribute defines the lifetime of the
cookie, in seconds. The delta-seconds value is a decimal non-
negative integer. After delta-seconds seconds elapse, the
client should discard the cookie. A value of zero means the
cookie should be discarded immediately.
*/
strstore(&co->maxage, whatptr);
if(!co->maxage) {
badcookie = TRUE;
break;
}
co->expires =
strtol((*co->maxage=='\"')?&co->maxage[1]:&co->maxage[0],NULL,10)
+ (long)now;
}
else if(Curl_raw_equal("expires", name)) {
strstore(&co->expirestr, whatptr);
if(!co->expirestr) {
badcookie = TRUE;
break;
}
/* Note that if the date couldn't get parsed for whatever reason,
the cookie will be treated as a session cookie */
co->expires = curl_getdate(what, &now);
/* Session cookies have expires set to 0 so if we get that back
from the date parser let's add a second to make it a
non-session cookie */
if(co->expires == 0)
co->expires = 1;
else if(co->expires < 0)
co->expires = 0;
}
else if(!co->name) {
co->name = strdup(name);
co->value = strdup(whatptr);
if(!co->name || !co->value) {
badcookie = TRUE;
break;
}
}
/*
else this is the second (or more) name we don't know
about! */
}
else {
/* this is an "illegal" <what>=<this> pair */
}
if(!semiptr || !*semiptr) {
/* we already know there are no more cookies */
semiptr = NULL;
continue;
}
ptr=semiptr+1;
while(*ptr && ISBLANK(*ptr))
ptr++;
semiptr=strchr(ptr, ';'); /* now, find the next semicolon */
if(!semiptr && *ptr)
/* There are no more semicolons, but there's a final name=value pair
coming up */
semiptr=strchr(ptr, '\0');
} while(semiptr);
if(!badcookie && !co->domain) {
if(domain) {
/* no domain was given in the header line, set the default */
co->domain=strdup(domain);
if(!co->domain)
badcookie = TRUE;
}
}
if(!badcookie && !co->path && path) {
/* No path was given in the header line, set the default.
Note that the passed-in path to this function MAY have a '?' and
following part that MUST not be stored as part of the path. */
char *queryp = strchr(path, '?');
/* queryp is where the interesting part of the path ends, so now we
want to the find the last */
char *endslash;
if(!queryp)
endslash = strrchr(path, '/');
else
endslash = memrchr(path, '/', (size_t)(queryp - path));
if(endslash) {
size_t pathlen = (size_t)(endslash-path+1); /* include ending slash */
co->path=malloc(pathlen+1); /* one extra for the zero byte */
if(co->path) {
memcpy(co->path, path, pathlen);
co->path[pathlen]=0; /* zero terminate */
co->spath = sanitize_cookie_path(co->path);
if(!co->spath)
badcookie = TRUE; /* out of memory bad */
}
else
badcookie = TRUE;
}
}
free(what);
if(badcookie || !co->name) {
/* we didn't get a cookie name or a bad one,
this is an illegal line, bail out */
freecookie(co);
return NULL;
}
}
else {
/* This line is NOT a HTTP header style line, we do offer support for
reading the odd netscape cookies-file format here */
char *ptr;
char *firstptr;
char *tok_buf=NULL;
int fields;
/* IE introduced HTTP-only cookies to prevent XSS attacks. Cookies
marked with httpOnly after the domain name are not accessible
from javascripts, but since curl does not operate at javascript
level, we include them anyway. In Firefox's cookie files, these
lines are preceded with #HttpOnly_ and then everything is
as usual, so we skip 10 characters of the line..
*/
if(strncmp(lineptr, "#HttpOnly_", 10) == 0) {
lineptr += 10;
co->httponly = TRUE;
}
if(lineptr[0]=='#') {
/* don't even try the comments */
free(co);
return NULL;
}
/* strip off the possible end-of-line characters */
ptr=strchr(lineptr, '\r');
if(ptr)
*ptr=0; /* clear it */
ptr=strchr(lineptr, '\n');
if(ptr)
*ptr=0; /* clear it */
firstptr=strtok_r(lineptr, "\t", &tok_buf); /* tokenize it on the TAB */
/* Now loop through the fields and init the struct we already have
allocated */
for(ptr=firstptr, fields=0; ptr && !badcookie;
ptr=strtok_r(NULL, "\t", &tok_buf), fields++) {
switch(fields) {
case 0:
if(ptr[0]=='.') /* skip preceding dots */
ptr++;
co->domain = strdup(ptr);
if(!co->domain)
badcookie = TRUE;
break;
case 1:
/* This field got its explanation on the 23rd of May 2001 by
Andrés García:
flag: A TRUE/FALSE value indicating if all machines within a given
domain can access the variable. This value is set automatically by
the browser, depending on the value you set for the domain.
As far as I can see, it is set to true when the cookie says
.domain.com and to false when the domain is complete www.domain.com
*/
co->tailmatch = Curl_raw_equal(ptr, "TRUE")?TRUE:FALSE;
break;
case 2:
/* It turns out, that sometimes the file format allows the path
field to remain not filled in, we try to detect this and work
around it! Andrés García made us aware of this... */
if(strcmp("TRUE", ptr) && strcmp("FALSE", ptr)) {
/* only if the path doesn't look like a boolean option! */
co->path = strdup(ptr);
if(!co->path)
badcookie = TRUE;
else {
co->spath = sanitize_cookie_path(co->path);
if(!co->spath) {
badcookie = TRUE; /* out of memory bad */
}
}
break;
}
/* this doesn't look like a path, make one up! */
co->path = strdup("/");
if(!co->path)
badcookie = TRUE;
co->spath = strdup("/");
if(!co->spath)
badcookie = TRUE;
fields++; /* add a field and fall down to secure */
/* FALLTHROUGH */
case 3:
co->secure = Curl_raw_equal(ptr, "TRUE")?TRUE:FALSE;
break;
case 4:
co->expires = curlx_strtoofft(ptr, NULL, 10);
break;
case 5:
co->name = strdup(ptr);
if(!co->name)
badcookie = TRUE;
break;
case 6:
co->value = strdup(ptr);
if(!co->value)
badcookie = TRUE;
break;
}
}
if(6 == fields) {
/* we got a cookie with blank contents, fix it */
co->value = strdup("");
if(!co->value)
badcookie = TRUE;
else
fields++;
}
if(!badcookie && (7 != fields))
/* we did not find the sufficient number of fields */
badcookie = TRUE;
if(badcookie) {
freecookie(co);
return NULL;
}
}
if(!c->running && /* read from a file */
c->newsession && /* clean session cookies */
!co->expires) { /* this is a session cookie since it doesn't expire! */
freecookie(co);
return NULL;
}
co->livecookie = c->running;
/* now, we have parsed the incoming line, we must now check if this
superceeds an already existing cookie, which it may if the previous have
the same domain and path as this */
/* at first, remove expired cookies */
remove_expired(c);
clist = c->cookies;
replace_old = FALSE;
while(clist) {
if(Curl_raw_equal(clist->name, co->name)) {
/* the names are identical */
if(clist->domain && co->domain) {
if(Curl_raw_equal(clist->domain, co->domain))
/* The domains are identical */
replace_old=TRUE;
}
else if(!clist->domain && !co->domain)
replace_old = TRUE;
if(replace_old) {
/* the domains were identical */
if(clist->spath && co->spath) {
if(Curl_raw_equal(clist->spath, co->spath)) {
replace_old = TRUE;
}
else
replace_old = FALSE;
}
else if(!clist->spath && !co->spath)
replace_old = TRUE;
else
replace_old = FALSE;
}
if(replace_old && !co->livecookie && clist->livecookie) {
/* Both cookies matched fine, except that the already present
cookie is "live", which means it was set from a header, while
the new one isn't "live" and thus only read from a file. We let
live cookies stay alive */
/* Free the newcomer and get out of here! */
freecookie(co);
return NULL;
}
if(replace_old) {
co->next = clist->next; /* get the next-pointer first */
/* then free all the old pointers */
free(clist->name);
if(clist->value)
free(clist->value);
if(clist->domain)
free(clist->domain);
if(clist->path)
free(clist->path);
if(clist->spath)
free(clist->spath);
if(clist->expirestr)
free(clist->expirestr);
if(clist->version)
free(clist->version);
if(clist->maxage)
free(clist->maxage);
*clist = *co; /* then store all the new data */
free(co); /* free the newly alloced memory */
co = clist; /* point to the previous struct instead */
/* We have replaced a cookie, now skip the rest of the list but
make sure the 'lastc' pointer is properly set */
do {
lastc = clist;
clist = clist->next;
} while(clist);
break;
}
}
lastc = clist;
clist = clist->next;
}
if(c->running)
/* Only show this when NOT reading the cookies from a file */
infof(data, "%s cookie %s=\"%s\" for domain %s, path %s, "
"expire %" FORMAT_OFF_T "\n",
replace_old?"Replaced":"Added", co->name, co->value,
co->domain, co->path, co->expires);
if(!replace_old) {
/* then make the last item point on this new one */
if(lastc)
lastc->next = co;
else
c->cookies = co;
c->numcookies++; /* one more cookie in the jar */
}
return co;
}
/*
* fword --
* Move forward by words.
*/
static int
fword(SCR *sp, VICMD *vp, enum which type)
{
enum { INWORD, NOTWORD } state;
VCS cs;
u_long cnt;
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = vp->m_start.cno;
if (cs_init(sp, &cs))
return (1);
/*
* If in white-space:
* If the count is 1, and it's a change command, we're done.
* Else, move to the first non-white-space character, which
* counts as a single word move. If it's a motion command,
* don't move off the end of the line.
*/
if (cs.cs_flags == CS_EMP || (cs.cs_flags == 0 && ISBLANK(cs.cs_ch))) {
if (ISMOTION(vp) && cs.cs_flags != CS_EMP && cnt == 1) {
if (ISCMD(vp->rkp, 'c'))
return (0);
if (ISCMD(vp->rkp, 'd') || ISCMD(vp->rkp, 'y')) {
if (cs_fspace(sp, &cs))
return (1);
goto ret;
}
}
if (cs_fblank(sp, &cs))
return (1);
--cnt;
}
/*
* Cyclically move to the next word -- this involves skipping
* over word characters and then any trailing non-word characters.
* Note, for the 'w' command, the definition of a word keeps
* switching.
*/
if (type == BIGWORD)
while (cnt--) {
for (;;) {
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
}
/*
* If a motion command and we're at the end of the
* last word, we're done. Delete and yank eat any
* trailing blanks, but we don't move off the end
* of the line regardless.
*/
if (cnt == 0 && ISMOTION(vp)) {
if ((ISCMD(vp->rkp, 'd') ||
ISCMD(vp->rkp, 'y')) &&
cs_fspace(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
else
while (cnt--) {
state = cs.cs_flags == 0 &&
inword(cs.cs_ch) ? INWORD : NOTWORD;
for (;;) {
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
break;
if (state == INWORD) {
if (!inword(cs.cs_ch))
break;
} else
if (inword(cs.cs_ch))
break;
}
/* See comment above. */
if (cnt == 0 && ISMOTION(vp)) {
if ((ISCMD(vp->rkp, 'd') ||
ISCMD(vp->rkp, 'y')) &&
cs_fspace(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs.cs_flags != 0 || ISBLANK(cs.cs_ch))
if (cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
/*
* If we didn't move, we must be at EOF.
*
* !!!
* That's okay for motion commands, however.
*/
ret: if (!ISMOTION(vp) &&
cs.cs_lno == vp->m_start.lno && cs.cs_cno == vp->m_start.cno) {
v_eof(sp, &vp->m_start);
return (1);
}
/* Adjust the end of the range for motion commands. */
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
if (ISMOTION(vp) && cs.cs_flags == 0)
--vp->m_stop.cno;
/*
* Non-motion commands move to the end of the range. Delete
* and yank stay at the start, ignore others.
*/
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
return (0);
}
/* Match pattern "p" against "text" */
static int dowild(const uchar *p, const uchar *text, unsigned int flags)
{
uchar p_ch;
const uchar *pattern = p;
int pattern_needs_leading_period =
(flags & WM_PERIOD) && (text[0] == '.');
for ( ; (p_ch = *p) != '\0'; text++, p++) {
int matched, match_slash, negated;
uchar t_ch, prev_ch;
if ((t_ch = *text) == '\0' && p_ch != '*')
return WM_ABORT_ALL;
if ((flags & WM_CASEFOLD) && ISUPPER(t_ch))
t_ch = tolower(t_ch);
if ((flags & WM_CASEFOLD) && ISUPPER(p_ch))
p_ch = tolower(p_ch);
switch (p_ch) {
case '\\':
if (!(flags & WM_NOESCAPE))
/* Literal match with following character. Note that the test
* in "default" handles the p[1] == '\0' failure case. */
p_ch = *++p;
/* FALLTHROUGH */
default:
if (t_ch != p_ch)
return WM_NOMATCH;
if ((flags & WM_PERIOD) &&
(flags & WM_PATHNAME) && t_ch == '/' &&
text[1] == '.' && p[1] != '.')
return WM_NOMATCH;
/* If we needed a leading period, we've matched it. */
pattern_needs_leading_period = 0;
continue;
case '?':
/* Match anything but '/'. */
if ((flags & WM_PATHNAME) && t_ch == '/')
return WM_NOMATCH;
continue;
case '*':
if (*++p == '*') {
const uchar *prev_p = p - 2;
while (*++p == '*') {}
if (!(flags & WM_PATHNAME))
/* without WM_PATHNAME, '*' == '**' */
match_slash = 1;
else if ((prev_p < pattern || *prev_p == '/') &&
(*p == '\0' || *p == '/' ||
(p[0] == '\\' && p[1] == '/'))) {
/*
* Assuming we already match 'foo/' and are at
* <star star slash>, just assume it matches
* nothing and go ahead match the rest of the
* pattern with the remaining string. This
* helps make foo/<*><*>/bar (<> because
* otherwise it breaks C comment syntax) match
* both foo/bar and foo/a/bar.
*/
if (p[0] == '/' &&
dowild(p + 1, text, flags) == WM_MATCH)
return WM_MATCH;
match_slash = 1;
} else
return WM_ABORT_MALFORMED;
} else
/* without WM_PATHNAME, '*' == '**' */
match_slash = flags & WM_PATHNAME ? 0 : 1;
if (*p == '\0') {
/* If we needed a leading period in the pattern but only
* found stars, we didn't match. */
if (pattern_needs_leading_period)
return WM_NOMATCH;
/* Trailing "**" matches everything. Trailing "*" matches
* only if there are no more slash characters. */
if (!match_slash) {
if (strchr((char*)text, '/') != NULL)
return WM_NOMATCH;
if ((flags & WM_PERIOD) &&
strstr((const char*)text, "/.") != NULL)
return WM_NOMATCH;
}
return WM_MATCH;
} else if (!match_slash && *p == '/') {
/*
* _one_ asterisk followed by a slash
* with WM_PATHNAME matches the next
* directory
*/
const char *slash = strchr((char*)text, '/');
if (!slash)
return WM_NOMATCH;
text = (const uchar*)slash;
/* the slash is consumed by the top-level for loop */
break;
}
while (1) {
if (t_ch == '\0')
break;
/*
* Try to advance faster when an asterisk is
* followed by a literal. We know in this case
* that the the string before the literal
* must belong to "*".
* If match_slash is false, do not look past
* the first slash as it cannot belong to '*'.
*/
if (!is_glob_special(*p)) {
p_ch = *p;
if ((flags & WM_CASEFOLD) && ISUPPER(p_ch))
p_ch = tolower(p_ch);
while ((t_ch = *text) != '\0' &&
(match_slash || t_ch != '/')) {
if ((flags & WM_CASEFOLD) && ISUPPER(t_ch))
t_ch = tolower(t_ch);
if (t_ch == p_ch)
break;
text++;
}
if (t_ch != p_ch)
return WM_NOMATCH;
}
if (pattern_needs_leading_period)
return WM_NOMATCH;
if ((matched = dowild(p, text, flags)) != WM_NOMATCH) {
if (!match_slash || matched != WM_ABORT_TO_STARSTAR)
return matched;
} else if (!match_slash && t_ch == '/')
return WM_ABORT_TO_STARSTAR;
else if ((flags & WM_PERIOD) &&
(flags & WM_PATHNAME) && t_ch == '/' &&
text[1] == '.' && p[1] != '.')
return WM_NOMATCH;
t_ch = *++text;
}
return WM_ABORT_ALL;
case '[':
p_ch = *++p;
#ifdef NEGATE_CLASS2
if (p_ch == NEGATE_CLASS2)
p_ch = NEGATE_CLASS;
#endif
/* Assign literal 1/0 because of "matched" comparison. */
negated = p_ch == NEGATE_CLASS ? 1 : 0;
if (negated) {
/* Inverted character class. */
p_ch = *++p;
}
prev_ch = 0;
matched = 0;
do {
if (!p_ch)
return WM_ABORT_ALL;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return WM_ABORT_ALL;
if (t_ch == p_ch)
matched = 1;
} else if (p_ch == '-' && prev_ch && p[1] && p[1] != ']') {
p_ch = *++p;
if (p_ch == '\\') {
p_ch = *++p;
if (!p_ch)
return WM_ABORT_ALL;
}
if (t_ch <= p_ch && t_ch >= prev_ch)
matched = 1;
else if ((flags & WM_CASEFOLD) && ISLOWER(t_ch)) {
uchar t_ch_upper = toupper(t_ch);
if (t_ch_upper <= p_ch && t_ch_upper >= prev_ch)
matched = 1;
}
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (p_ch == '[' && p[1] == ':') {
const uchar *s;
int i;
for (s = p += 2; (p_ch = *p) && p_ch != ']'; p++) {} /*SHARED ITERATOR*/
if (!p_ch)
return WM_ABORT_ALL;
i = p - s - 1;
if (i < 0 || p[-1] != ':') {
/* Didn't find ":]", so treat like a normal set. */
p = s - 2;
p_ch = '[';
if (t_ch == p_ch)
matched = 1;
continue;
}
if (CC_EQ(s,i, "alnum")) {
if (ISALNUM(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "alpha")) {
if (ISALPHA(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "blank")) {
if (ISBLANK(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "cntrl")) {
if (ISCNTRL(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "digit")) {
if (ISDIGIT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "graph")) {
if (ISGRAPH(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "lower")) {
if (ISLOWER(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "print")) {
if (ISPRINT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "punct")) {
if (ISPUNCT(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "space")) {
if (ISSPACE(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "upper")) {
if (ISUPPER(t_ch))
matched = 1;
else if ((flags & WM_CASEFOLD) && ISLOWER(t_ch))
matched = 1;
} else if (CC_EQ(s,i, "xdigit")) {
if (ISXDIGIT(t_ch))
matched = 1;
} else /* malformed [:class:] string */
return WM_ABORT_ALL;
p_ch = 0; /* This makes "prev_ch" get set to 0. */
} else if (t_ch == p_ch)
matched = 1;
} while (prev_ch = p_ch, (p_ch = *++p) != ']');
if (matched == negated ||
((flags & WM_PATHNAME) && t_ch == '/'))
return WM_NOMATCH;
if ((flags & WM_PATHNAME) && t_ch == '/' &&
(flags & WM_PERIOD) && (text[1] == '.') && (p[1] != '.'))
return WM_NOMATCH;
continue;
}
}
return *text ? WM_NOMATCH : WM_MATCH;
}
/* Use script to produce jpeg frames */
void script_animate (int iw)
{
char buf[SCRIPT_LINE_SIZE],output[SCRIPT_LINE_SIZE],*ptr;
int i,hascontent,quality,frames;
FILE *fp;
glob_t globbuf;
strcpy(buf, "scr_anim");
if (!(fp=ropen(buf)))
{
printf ("\nAnimation script \"%s\" does not exist,\n", buf);
xterm_get_focus(iw); clear_stdin_buffer();
if (!strcasecmp("y", readline_gets
("Do you want a default one created (y/n)?","y")))
{
numerically_sorted_glob (config_fname, &globbuf);
fp=wopen(buf);
fprintf (fp, "%d\n", AX_JPG_DEF_QUALITY);
for (i=0; i<globbuf.gl_pathc; i++)
fprintf (fp, "%s Jpg/%05d.jpg\n", globbuf.gl_pathv[i], i);
globfree (&globbuf);
fclose(fp);
fp = ropen(buf);
}
else
{
xterm_release_focus(iw);
return;
}
}
if (!(ptr=fgets(buf,SCRIPT_LINE_SIZE,fp)))
{
printf ("\nThere is nothing in animation script \"%s\".\n", buf);
fclose (fp);
return;
}
for (hascontent=i=0; (buf[i]!=EOS) &&
(ISDIGIT(buf[i]) || ISBLANK(buf[i]) || (buf[i]=='\n')); i++)
if (ISALNUM(buf[i])) hascontent=1;
if (!hascontent)
{
printf ("\nThere is no content in animation script \"%s\".\n", buf);
fclose (fp);
return;
}
if (buf[i] == EOS)
{
sscanf (buf, "%d", &quality);
if ((quality<0) || (quality>100))
{
printf ("\nquality = %d is out of valid range ([0,100]).\n",
quality);
return;
}
else printf ("\nquality = %d\n", quality);
ptr = fgets(buf,SCRIPT_LINE_SIZE,fp);
}
else quality = AX_JPG_DEF_QUALITY;
frames = 0;
/* If bonds are not on now, there is no need to refresh */
temporary_disable_bond = !n[iw].bond_mode;
/* cylinder data structure during the rendering. */
while (ptr)
{
buf[SCRIPT_LINE_CHAR] = EOS;
sscanf (buf, "%s %s", config_fname, output);
reload_config (iw, FALSE);
paint_scene(iw);
AX_dump(iw); AX_show(iw);
if (str_caseend_with(output,".png"))
AX_save_pixmap_as_png
(iw,AX_JPG_QUALITY_TO_PNG_LEVEL(quality),output);
else if (str_caseend_with(output,".eps"))
AX_save_pixmap_as_eps(iw,quality,output);
else AX_save_pixmap_as_jpg(iw,quality,output);
frames++;
ptr = fgets(buf,SCRIPT_LINE_SIZE,fp);
}
fclose(fp);
printf ("%d frames saved.\n\n", frames);
if (temporary_disable_bond)
{
Config_to_3D_Bonds (n[iw].bond_radius);
if (n[iw].bond_mode)
{
bond_xtal_origin_update (iw);
bond_atom_color_update(iw);
}
else
{
n[iw].bond_xtal_origin_need_update = TRUE;
n[iw].bond_atom_color_need_update = TRUE;
}
temporary_disable_bond = 0;
}
return;
} /* end script_animate() */
