static const char *find_encoding(const char *begin, const char *end)
{
const char *needle = "\nencoding ";
char *bol, *eol;
bol = memmem(begin, end ? end - begin : strlen(begin),
needle, strlen(needle));
if (!bol)
return git_commit_encoding;
bol += strlen(needle);
eol = strchrnul(bol, '\n');
*eol = '\0';
return bol;
}
/*
* We anonymize each component of a path individually,
* so that paths a/b and a/c will share a common root.
* The paths are cached via anonymize_mem so that repeated
* lookups for "a" will yield the same value.
*/
static void anonymize_path(struct strbuf *out, const char *path,
struct hashmap *map,
void *(*generate)(const void *, size_t *))
{
while (*path) {
const char *end_of_component = strchrnul(path, '/');
size_t len = end_of_component - path;
const char *c = anonymize_mem(map, generate, path, &len);
strbuf_add(out, c, len);
path = end_of_component;
if (*path)
strbuf_addch(out, *path++);
}
}
static GList*
split_string_on_char(const char *str, char ch)
{
GList *list = NULL;
for (;;)
{
const char *delim = strchrnul(str, ch);
list = g_list_prepend(list, xstrndup(str, delim - str));
if (*delim == '\0')
break;
str = delim + 1;
}
return g_list_reverse(list);
}
static void show_sig_lines(struct rev_info *opt, int status, const char *bol)
{
const char *color, *reset, *eol;
color = diff_get_color_opt(&opt->diffopt,
status ? DIFF_WHITESPACE : DIFF_FRAGINFO);
reset = diff_get_color_opt(&opt->diffopt, DIFF_RESET);
while (*bol) {
eol = strchrnul(bol, '\n');
printf("%s%.*s%s%s", color, (int)(eol - bol), bol, reset,
*eol ? "\n" : "");
bol = (*eol) ? (eol + 1) : eol;
}
}
char *
undebugq3(char *in, char *needle)
{
char *p = NULL;
char *pt = in -1;// temporary pointer
do {
p = pt + 1;
if ((pt = strmatch(p, needle)) != NULL) {
if (*pt == ' ') {
char *ip = pt + 1;
char *ipt = NULL;
size_t nsize = pt - p;
do {
ipt = strchrnul(ip,' ');
if (*ipt == ' ') {
if ( backcmp(ipt - nsize, needle, nsize) ) {
ip = ipt;
continue;
} else {
user_memmove(p, pt+1, ipt-pt-1-nsize);
p += ipt-pt-1-nsize;
ip = ipt+1;
pt = ipt;
continue;
}
}
if (*ipt == '\0') {
if ( backcmp(ipt - nsize, needle, nsize) ) {
user_memmove(p, pt+1, ipt-pt);
} else {
user_memmove(p, pt+1, ipt - pt - nsize - 1);
p += ipt - pt - nsize - 1;
*p = '\0';
}
return in;
}
} while(*(ip++));
return in;
}
if (*pt == '\0') {
*p = '\0';
return in;
}
p = pt;
}
pt = strchr(p, ' ');
} while (pt);
return in;
}
enum debug_flag_t debug_flags_from_string(enum debug_flag_t initial,
const _TCHAR * source_name,
const _TCHAR * str)
{
enum debug_flag_t rc = initial;
while (str)
{
if (*str == _T('\0'))
break;
const char *envtokend = strchrnul(str, ',');
bool found = false;
bool remove = false;
if ((str[0] == '-') || (str[0] == '+'))
{
remove = (str[0] == '-');
str++;
}
for (size_t ii = 0; debug_flag_env_names[ii].df_env_name; ii++)
{
if (strncasecmp(str, debug_flag_env_names[ii].df_env_name, envtokend - str) == 0)
{
found = true;
if (remove)
rc = (enum debug_flag_t) (rc & ~debug_flag_env_names[ii].df);
else
rc = (enum debug_flag_t) (rc | debug_flag_env_names[ii].df);
break;
}
}
if (!found)
{
dscwritef(DF_ALWAYS, ("Unknown debug flag while parsing ~cs, starting here: ~cs\n", source_name, str));
show_debug_flags();
panic("Aborting Run");
}
str = (char *) ((*envtokend == '\0') ? NULL : envtokend + 1);
}
return rc;
}
static void foreach_reported_to_line(const char *reported_to, foreach_reported_to_line_cb_type callback, void *user_data)
{
const char *p = reported_to;
unsigned lineno = 0;
while (*p)
{
++lineno;
const char *record = p;
const char *record_label_end = strchrnul(p, ':');
const size_t label_len = record_label_end - p;
const char *record_end = strchrnul(p, '\n');
p = record_end + (record_end[0] != '\0');
if (label_len == 0 || record_label_end[0] == '\0' || record_end < record_label_end)
{
log_notice("Miss formatted 'reported_to' record on line %d", lineno);
continue;
}
callback(record, label_len, user_data);
}
}
static void strbuf_add_indented_text(struct strbuf *buf, const char *text,
int indent, int indent2)
{
if (indent < 0)
indent = 0;
while (*text) {
const char *eol = strchrnul(text, '\n');
if (*eol == '\n')
eol++;
strbuf_addchars(buf, ' ', indent);
strbuf_add(buf, text, eol - text);
text = eol;
indent = indent2;
}
}
char *
undebugq2(char *in, char *needle)
{
char *p = NULL;
char *pt = in-1; // temporary pointer
do {
p = pt + 1;
if ((pt = strmatch(p, needle)) != NULL) {
if (*pt == ' ') {
char *ip = pt + 1;
char *ipt = NULL;
do {
if ((ipt = strmatch(ip, needle)) != NULL) {
if (*ipt == ' ') {
user_memmove(p, pt+1, ip-pt-1);
p += ip-pt-1;
ip = ipt+1;
pt = ipt;
}
if (*ipt == '\0') {
if (ip - pt - 1) {
user_memmove(p, pt+1, ip-pt-1);
p += ip-pt-2;
}
*p = '\0';
return in;
}
ip = ipt;
}
ip = strchrnul(ip, ' ');
if (!(*ip)) {
user_memmove(p, pt+1, ip-pt);
return in;
}
ip++;
} while (*ip);
return in;
}
if (*pt == '\0') {
*p = '\0';
return in;
}
p = pt;
}
pt = strchr(p, ' ');
} while (pt);
return in;
}
static const char* findInPath(const char* file)
{
static __thread char buffer[DARWIN_MAXPATHLEN];
if (*file == '/')
return file;
if (strchr(file, '/') != 0)
{
// No PATH resolution, only fix the case
strcpy(buffer, file);
translatePathCI(buffer);
return buffer;
}
const char* path = getenv("PATH");
if (!path)
{
// Get the default path.
size_t len = confstr(_CS_PATH, 0, 0);
char* buf = reinterpret_cast<char*>( alloca(len + 1) );
buf[0] = ':';
confstr(_CS_PATH, buf + 1, len);
path = buf;
}
const char* p = path;
do
{
const char* end = strchrnul(p, ':');
size_t len = end-p;
memcpy(buffer, p, len);
if (buffer[len-1] != '/')
buffer[len++] = '/';
strcpy(buffer+len, file);
translatePathCI(buffer);
if (::access(buffer, X_OK) == 0)
return buffer;
}
while (*p++);
return 0;
}
static void http_auth_init(const char *url)
{
char *at, *colon, *cp, *slash, *decoded;
int len;
cp = strstr(url, "://");
if (!cp)
return;
/*
* Ok, the URL looks like "proto://something". Which one?
* "proto://<user>:<pass>@<host>/...",
* "proto://<user>@<host>/...", or just
* "proto://<host>/..."?
*/
cp += 3;
at = strchr(cp, '@');
colon = strchr(cp, ':');
slash = strchrnul(cp, '/');
if (!at || slash <= at)
return; /* No credentials */
if (!colon || at <= colon) {
/* Only username */
len = at - cp;
user_name = xmalloc(len + 1);
memcpy(user_name, cp, len);
user_name[len] = '\0';
decoded = url_decode(user_name);
free(user_name);
user_name = decoded;
user_pass = NULL;
} else {
len = colon - cp;
user_name = xmalloc(len + 1);
memcpy(user_name, cp, len);
user_name[len] = '\0';
decoded = url_decode(user_name);
free(user_name);
user_name = decoded;
len = at - (colon + 1);
user_pass = xmalloc(len + 1);
memcpy(user_pass, colon + 1, len);
user_pass[len] = '\0';
decoded = url_decode(user_pass);
free(user_pass);
user_pass = decoded;
}
}
unsigned parse_whitespace_rule(const char *string)
{
unsigned rule = WS_DEFAULT_RULE;
while (string) {
int i;
size_t len;
const char *ep;
int negated = 0;
string = string + strspn(string, ", \t\n\r");
ep = strchrnul(string, ',');
len = ep - string;
if (*string == '-') {
negated = 1;
string++;
len--;
}
if (!len)
break;
for (i = 0; i < ARRAY_SIZE(whitespace_rule_names); i++) {
if (strncmp(whitespace_rule_names[i].rule_name,
string, len))
continue;
if (negated)
rule &= ~whitespace_rule_names[i].rule_bits;
else
rule |= whitespace_rule_names[i].rule_bits;
break;
}
if (strncmp(string, "tabwidth=", 9) == 0) {
unsigned tabwidth = atoi(string + 9);
if (0 < tabwidth && tabwidth < 0100) {
rule &= ~WS_TAB_WIDTH_MASK;
rule |= tabwidth;
}
else
warning("tabwidth %.*s out of range",
(int)(len - 9), string + 9);
}
string = ep;
}
if (rule & WS_TAB_IN_INDENT && rule & WS_INDENT_WITH_NON_TAB)
die("cannot enforce both tab-in-indent and indent-with-non-tab");
return rule;
}
static void read_mailmap_buf(struct string_list *map,
const char *buf, unsigned long len,
char **repo_abbrev)
{
while (len) {
const char *end = strchrnul(buf, '\n');
unsigned long linelen = end - buf + 1;
char *line = xmemdupz(buf, linelen);
read_mailmap_line(map, line, repo_abbrev);
free(line);
buf += linelen;
len -= linelen;
}
}
int main(void)
{
char string[N];
char c;
printf("Input a string!\n");
gets(string);
printf("Input a character to look up for!\n");
scanf("%c",&c);
char *rp = strchrnul(string,c);
printf("The 1th character '%c' that found, the next character is '%c'\n",*rp,*(rp+1));
return 0;
}
bool is_in_comma_separated_list(const char *value, const char *list)
{
if (!list)
return false;
unsigned len = strlen(value);
while (*list)
{
const char *comma = strchrnul(list, ',');
if ((comma - list == len) && strncmp(value, list, len) == 0)
return true;
if (!*comma)
break;
list = comma + 1;
}
return false;
}
static inline void add_cookie(struct hashtable *ht, const char *str) {
const char *name = str;
const char *name_end = strchrnul(str, '=');
const char *val = *name_end ? name_end + 1 : name_end;
/* get rid of quotes */
const char *val_st = val, *val_st_end = val + strlen(val);
if ('"' == *val_st)
++val_st;
if (val_st != val_st_end && '"' == *(val_st_end - 1))
--val_st_end;
size_t l = val_st_end - val_st;
uint32_t loc = hashtable_insert(ht, name, name_end - name, val_st, l + 1);
*(char *)(hashtable_get_val(ht, loc) + l) = 0;
}
static void
crm_log_filter(struct qb_log_callsite *cs)
{
int lpc = 0;
static int need_init = 1;
static const char *trace_fns = NULL;
static const char *trace_tags = NULL;
static const char *trace_fmts = NULL;
static const char *trace_files = NULL;
static const char *trace_blackbox = NULL;
if (need_init) {
need_init = 0;
trace_fns = getenv("PCMK_trace_functions");
trace_fmts = getenv("PCMK_trace_formats");
trace_tags = getenv("PCMK_trace_tags");
trace_files = getenv("PCMK_trace_files");
trace_blackbox = getenv("PCMK_trace_blackbox");
if (trace_tags != NULL) {
uint32_t tag;
char token[500];
const char *offset = NULL;
const char *next = trace_tags;
do {
offset = next;
next = strchrnul(offset, ',');
snprintf(token, 499, "%.*s", (int)(next - offset), offset);
tag = g_quark_from_string(token);
crm_info("Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);
if (next[0] != 0) {
next++;
}
} while (next != NULL && next[0] != 0);
}
}
cs->targets = 0; /* Reset then find targets to enable */
for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
cs);
}
}
static int rerere_mem_getline(struct strbuf *sb, struct rerere_io *io_)
{
struct rerere_io_mem *io = (struct rerere_io_mem *)io_;
char *ep;
size_t len;
strbuf_release(sb);
if (!io->input.len)
return -1;
ep = strchrnul(io->input.buf, '\n');
if (*ep == '\n')
ep++;
len = ep - io->input.buf;
strbuf_add(sb, io->input.buf, len);
strbuf_remove(&io->input, 0, len);
return 0;
}
static void parse_signature_lines(struct format_commit_context *ctx)
{
const char *buf = ctx->signature.gpg_output;
int i;
for (i = 0; i < ARRAY_SIZE(signature_check); i++) {
const char *found = strstr(buf, signature_check[i].check);
const char *next;
if (!found)
continue;
ctx->signature.good_bad = signature_check[i].result;
found += strlen(signature_check[i].check);
next = strchrnul(found, '\n');
ctx->signature.signer = xmemdupz(found, next - found);
break;
}
}
static int do_invalidate_path(struct cache_tree *it, const char *path)
{
/* a/b/c
* ==> invalidate self
* ==> find "a", have it invalidate "b/c"
* a
* ==> invalidate self
* ==> if "a" exists as a subtree, remove it.
*/
const char *slash;
int namelen;
struct cache_tree_sub *down;
#if DEBUG
fprintf(stderr, "cache-tree invalidate <%s>\n", path);
#endif
if (!it)
return 0;
slash = strchrnul(path, '/');
namelen = slash - path;
it->entry_count = -1;
if (!*slash) {
int pos;
pos = subtree_pos(it, path, namelen);
if (0 <= pos) {
cache_tree_free(&it->down[pos]->cache_tree);
free(it->down[pos]);
/* 0 1 2 3 4 5
* ^ ^subtree_nr = 6
* pos
* move 4 and 5 up one place (2 entries)
* 2 = 6 - 3 - 1 = subtree_nr - pos - 1
*/
memmove(it->down+pos, it->down+pos+1,
sizeof(struct cache_tree_sub *) *
(it->subtree_nr - pos - 1));
it->subtree_nr--;
}
return 1;
}
down = find_subtree(it, path, namelen, 0);
if (down)
do_invalidate_path(down->cache_tree, slash + 1);
return 1;
}
static int template_desc_init_fields(const char *template_fmt,
struct ima_template_field ***fields,
int *num_fields)
{
const char *template_fmt_ptr;
struct ima_template_field *found_fields[IMA_TEMPLATE_NUM_FIELDS_MAX];
int template_num_fields = template_fmt_size(template_fmt);
int i, len;
if (template_num_fields > IMA_TEMPLATE_NUM_FIELDS_MAX) {
pr_err("format string '%s' contains too many fields\n",
template_fmt);
return -EINVAL;
}
for (i = 0, template_fmt_ptr = template_fmt; i < template_num_fields;
i++, template_fmt_ptr += len + 1) {
char tmp_field_id[IMA_TEMPLATE_FIELD_ID_MAX_LEN + 1];
len = strchrnul(template_fmt_ptr, '|') - template_fmt_ptr;
if (len == 0 || len > IMA_TEMPLATE_FIELD_ID_MAX_LEN) {
pr_err("Invalid field with length %d\n", len);
return -EINVAL;
}
memcpy(tmp_field_id, template_fmt_ptr, len);
tmp_field_id[len] = '\0';
found_fields[i] = lookup_template_field(tmp_field_id);
if (!found_fields[i]) {
pr_err("field '%s' not found\n", tmp_field_id);
return -ENOENT;
}
}
if (fields && num_fields) {
*fields = kmalloc_array(i, sizeof(*fields), GFP_KERNEL);
if (*fields == NULL)
return -ENOMEM;
memcpy(*fields, found_fields, i * sizeof(*fields));
*num_fields = i;
}
return 0;
}
static int
dnsmasqCapsSetFromBuffer(dnsmasqCapsPtr caps, const char *buf)
{
const char *p;
caps->noRefresh = true;
p = STRSKIP(buf, DNSMASQ_VERSION_STR);
if (!p)
goto fail;
virSkipSpaces(&p);
if (virParseVersionString(p, &caps->version, true) < 0)
goto fail;
if (strstr(buf, "--bind-dynamic"))
dnsmasqCapsSet(caps, DNSMASQ_CAPS_BIND_DYNAMIC);
/* if this string is a part of the --version output, dnsmasq
* has been patched to use SO_BINDTODEVICE when listening,
* so that it will only accept requests that arrived on the
* listening interface(s)
*/
if (strstr(buf, "--bind-interfaces with SO_BINDTODEVICE"))
dnsmasqCapsSet(caps, DNSMASQ_CAPS_BINDTODEVICE);
if (strstr(buf, "--ra-param"))
dnsmasqCapsSet(caps, DNSMASQ_CAPS_RA_PARAM);
VIR_INFO("dnsmasq version is %d.%d, --bind-dynamic is %spresent, "
"SO_BINDTODEVICE is %sin use, --ra-param is %spresent",
(int)caps->version / 1000000,
(int)(caps->version % 1000000) / 1000,
dnsmasqCapsGet(caps, DNSMASQ_CAPS_BIND_DYNAMIC) ? "" : "NOT ",
dnsmasqCapsGet(caps, DNSMASQ_CAPS_BINDTODEVICE) ? "" : "NOT ",
dnsmasqCapsGet(caps, DNSMASQ_CAPS_RA_PARAM) ? "" : "NOT ");
return 0;
fail:
p = strchrnul(buf, '\n');
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse %s version number in '%.*s'"),
caps->binaryPath, (int) (p - buf), buf);
return -1;
}
static void add_branch_desc(struct strbuf *out, const char *name)
{
struct strbuf desc = STRBUF_INIT;
if (!read_branch_desc(&desc, name)) {
const char *bp = desc.buf;
while (*bp) {
const char *ep = strchrnul(bp, '\n');
if (*ep)
ep++;
strbuf_addf(out, " : %.*s", (int)(ep - bp), bp);
bp = ep;
}
if (out->buf[out->len - 1] != '\n')
strbuf_addch(out, '\n');
}
strbuf_release(&desc);
}
static void parse_user(const char *t, char **name, char **email, unsigned long *date, int *tz)
{
struct ident_split ident;
unsigned email_len;
if (!split_ident_line(&ident, t, strchrnul(t, '\n') - t)) {
*name = substr(ident.name_begin, ident.name_end);
email_len = ident.mail_end - ident.mail_begin;
*email = xmalloc(strlen("<") + email_len + strlen(">") + 1);
sprintf(*email, "<%.*s>", email_len, ident.mail_begin);
if (ident.date_begin)
*date = strtoul(ident.date_begin, NULL, 10);
if (ident.tz_begin)
*tz = atoi(ident.tz_begin);
}
}
void advise(const char *advice, ...)
{
struct strbuf buf = STRBUF_INIT;
va_list params;
const char *cp, *np;
va_start(params, advice);
strbuf_vaddf(&buf, advice, params);
va_end(params);
for (cp = buf.buf; *cp; cp = np) {
np = strchrnul(cp, '\n');
fprintf(stderr, _("hint: %.*s\n"), (int)(np - cp), cp);
if (*np)
np++;
}
strbuf_release(&buf);
}
static const char *quote_literal_for_format(const char *s)
{
static struct strbuf buf = STRBUF_INIT;
strbuf_reset(&buf);
while (*s) {
const char *ep = strchrnul(s, '%');
if (s < ep)
strbuf_add(&buf, s, ep - s);
if (*ep == '%') {
strbuf_addstr(&buf, "%%");
s = ep + 1;
} else {
s = ep;
}
}
return buf.buf;
}
bool is_in_comma_separated_list_of_glob_patterns(const char *value, const char *list)
{
if (!list)
return false;
while (*list)
{
const char *comma = strchrnul(list, ',');
char *pattern = xstrndup(list, comma - list);
int match = !fnmatch(pattern, value, /*flags:*/ 0);
free(pattern);
if (match)
return true;
if (!*comma)
break;
list = comma + 1;
}
return false;
}
static int32_t
_cs_matches_filter_(struct qb_log_callsite *cs,
enum qb_log_filter_type type,
const char *text,
uint8_t high_priority,
uint8_t low_priority)
{
int32_t match = QB_FALSE;
if (cs->priority > low_priority ||
cs->priority < high_priority) {
return QB_FALSE;
}
if (strcmp(text, "*") == 0) {
return QB_TRUE;
}
if (type == QB_LOG_FILTER_FILE ||
type == QB_LOG_FILTER_FUNCTION) {
char token[500];
const char *offset = NULL;
const char *next = text;
do {
offset = next;
next = strchrnul(offset, ',');
snprintf(token, 499, "%.*s", (int)(next - offset), offset);
if (type == QB_LOG_FILTER_FILE) {
match = (strstr(cs->filename, token) != NULL);
} else {
match = (strstr(cs->function, token) != NULL);
}
if (!match && next[0] != 0) {
next++;
}
} while (match == QB_FALSE && next != NULL && next[0] != 0);
} else if (type == QB_LOG_FILTER_FORMAT) {
if (strstr(cs->format, text)) {
match = QB_TRUE;
}
}
return match;
}
static void cmdline_tokenize(Cmdline *cmdline)
{
char ch[] = {0,'\0'};
int st, ed, pos;
char *str = cmdline->line;
bool esc = false;
st = ed = pos = 0;
for (;;) {
ch[0] = str[pos++];
if (ch[0] == '\0') {
create_token(cmdline->tokens, str, st, ed, false);
break;
}
else if (ch[0] == '\\' && !esc) {
esc = true;
continue;
}
else if ((ch[0] == '\"' || ch[0] == '\'') && !esc) {
char *closech = strchrnul(&str[pos], ch[0]);
if (closech[-1] != '\\') {
int end = (closech - &str[pos]) + pos;
bool quote = str[end] == '\0';
pos = quote ? pos-1 : pos;
create_token(cmdline->tokens, str, pos, end, !quote);
st = pos = quote ? end : ++end;
}
}
else if (strpbrk(ch, TOKENCHARS) && !esc) {
create_token(cmdline->tokens, str, st, ed, false);
if (*ch != ' ') {
create_token(cmdline->tokens, str, pos-1, pos, false);
ed = pos;
}
st = pos;
}
else
ed = pos;
esc = false;
}
cmdline->cont = esc;
}
std::string find_executable (const std::string &exe)
{
std::string result;
if (exe.empty ()) {
// Empty input. Return empty string
}
else if (memchr (exe.data (), '/', exe.length ())) {
// exe is a full/relative pathname
if (exe[0] == '~') {
result = home_expand_pathname (exe);
}
else {
result = exe;
}
if ((get_file_attr (result) & (FILE_ATTR_DIRECTORY|FILE_ATTR_EXECUTABLE))
!= FILE_ATTR_EXECUTABLE) {
result.clear ();
}
}
else if (const char *path = getenv ("PATH")) {
// exe is a "bare" filename
for (;;) {
const char *colon = strchrnul (path, ':');
if (path == colon) {
result = '.';
}
else {
result.assign (path, colon);
}
result += '/';
result += exe;
if ((get_file_attr (result) & (FILE_ATTR_DIRECTORY|FILE_ATTR_EXECUTABLE))
== FILE_ATTR_EXECUTABLE) {
break;
}
if (*colon != ':') {
result.clear ();
break;
}
path = colon+1;
}
}
return result;
}
