/* evaluate case conditional construct (3.9.4.3)
* ----------------------------------------------------------------------- */
int eval_case(struct eval *e, struct ncase *ncase) {
union node *node;
union node *pat;
int ret = 0;
stralloc word;
stralloc pattern;
stralloc_init(&word);
stralloc_init(&pattern);
if(ncase->word)
expand_catsa(ncase->word, &word, X_NOSPLIT);
stralloc_nul(&word);
for(node = ncase->list; node; node = node->list.next) {
for(pat = node->ncasenode.pats; pat; pat = pat->list.next) {
expand_catsa(pat, &pattern, X_NOSPLIT);
stralloc_nul(&pattern);
if(shell_fnmatch(pattern.s, pattern.len, word.s, word.len, SH_FNM_PERIOD) == 0) {
ret = eval_tree(e, node->ncasenode.cmds, E_LIST);
goto end;
}
stralloc_zero(&pattern);
}
}
end:
stralloc_free(&pattern);
stralloc_free(&word);
return ret;
}
int main(int argc, const char ** argv )
{
cmd = (char*) *argv++; --argc;
section = (char*) *argv++; --argc;
manual = (char*) *argv++; --argc;
stralloc tempCMD1 = {0};
tempCMD1 = generateSearchCMD( manual,tempCMD1);
int fd[2];
pipe(fd);
int status;
pid_t child;
if ( (child = fork() ) < 0 )
{
return 0;
}
else if( child == 0 )
{
dup2(fd[1],1);
close(fd[0]);
close(fd[1]);
system(tempCMD1.s);
stralloc_free(&tempCMD1);
exit(255);
}
else {
stralloc tempCMD2 = {0};
ssize_t nbytes;
char buff[64];
close(fd[1]);
while(( nbytes = read(fd[0] , buff , sizeof buff )) > 0 )
{
stralloc_catb( &tempCMD2 , buff , nbytes );
};
stralloc temp = {0};
stralloc_copys( &temp , cmdCAT );
stralloc_cat( &temp , &tempCMD2 );
char *t = temp.s;
printManual(t);
stralloc_free(&tempCMD2);
stralloc_free(&temp);
}
close(fd[0]);
close(fd[1]);
wait(&status);
return 0;
}
/* evaluates backquoted command list, while writing stdout to a stralloc
*/
union node*
expand_command(struct nargcmd *cmd, union node **nptr, struct vartab* varstack, int flags) {
union node *n = *nptr;
stralloc sa;
stralloc_init(&sa);
/* make the output buffer write to the stralloc */
buffer_tosa(buffer_1, &sa);
/* evaluate the command tree in a subshell */
/*sh_push(&sh);
sh_subshell(cmd->list, E_EXIT);
sh_pop(&sh);*/
/* split trailing newlines */
while(sa.len && sa.s[sa.len - 1] == '\n')
sa.len--;
/* expand the output of the command
FIXME: we could do this much nicer by doing an
expand_write() which is set as buffer op
on the output fd.
so we won't have to alloc all the stuff twice!
*/
n = expand_cat(sa.s, sa.len, nptr, varstack, flags);
stralloc_free(&sa);
return n;
}
char *get_name(FILE *f)
{
int c;
stralloc name = {0};
char *strp;
char d;
/* consume leading whitespace */
do {
c = fgetc(f);
} while(isspace(c));
ungetc(c, f);
/* append non-whitespace chars */
while (1) {
c = fgetc(f);
if (c < 0 || isspace(c)) {
stralloc_0(&name);
strp = strdup(name.s);
stralloc_free(&name);
return strp;
}
d = c;
stralloc_append(&name, &d);
}
}
int absolutepath (stralloc *sa, const char *path)
{
int r = 1 ;
if (!path) r = stralloc_copys(sa, "/") ;
else if (path[0] == '/') r = stralloc_copys(sa, path) ;
else
{
unsigned int n = 0 ;
for (;;)
{
n += 1024 ;
if (!stralloc_ready(sa, n))
{
r = 0 ;
break ;
}
if (getcwd(sa->s, n)) break ;
if (errno != ENOMEM)
{
r = 0 ;
break ;
}
}
sa->len = str_len(sa->s) ;
if (r) r = stralloc_append(sa, "/") && stralloc_cats(sa, path) ;
if (!r) stralloc_free(sa) ;
}
return r ? stralloc_0(sa) : 0 ;
}
/* process all here-docs
*
* nredir->data is set to the next here-doc redirection by redir_addhere()
* after processing it is set to the content of the here-doc (an narg node)
* ----------------------------------------------------------------------- */
void redir_source(void) {
struct parser p;
stralloc delim;
int r;
parse_init(&p, P_HERE);
stralloc_init(&delim);
for(; redir_list; redir_list = &redir_list->data->nredir) {
/* expand the delimiter */
stralloc_init(&delim);
expand_catsa((union node *)redir_list, &delim, 0);
/* when any character of the delimiter has been escaped
then treat the whole here-doc as non-expanded word */
r = parse_here(&p, &delim, (redir_list->list->nargstr.flag & S_ESCAPED));
tree_free(redir_list->list);
redir_list->list = parse_getarg(&p);
/* free expanded delimiters */
stralloc_free(&delim);
}
}
static void ftrigio_deepfree (ftrigio_t *p)
{
ftrig1_free(&p->trig) ;
stralloc_free(&p->sa) ;
regfree(&p->re) ;
*p = ftrigio_zero ;
}
void genalloc_deepfree_size (genalloc *g, freefunc_t_ref f, unsigned int size)
{
unsigned int len = g->len / size ;
register unsigned int i = 0 ;
for (; i < len ; i++) (*f)(g->s + i * size) ;
stralloc_free(g) ;
}
static void uniq (genalloc *lines)
{
unsigned int len = genalloc_len(stralloc, lines) ;
register stralloc *s = genalloc_s(stralloc, lines) ;
register unsigned int i = 1 ;
for (; i < len ; i++)
if (!sacmp(s+i-1, s+i)) stralloc_free(s+i-1) ;
}
static void cleanup (void)
{
int e = errno ;
satmp.s[llen] = 0 ;
unlink(satmp.s) ;
satmp.s[llen] = ':' ;
rm_rf_in_tmp(&satmp, 0) ;
stralloc_free(&satmp) ;
errno = e ;
}
int write_fifodir(char *dirname, stralloc *sa, void (*oaw_func)(char *, stralloc *))
{
DIR *dir = NULL;
stralloc name = {0};
struct dirent *x = NULL;
static struct stat st;
/* read directory */
dir = opendir(dirname);
if(dir == NULL)
{
strerr_warn3("can't opendir() ", dirname, ": ", &strerr_sys);
return -1;
}
while (x = readdir(dir))
{
if(x == NULL)
{
strerr_warn3("can't readdir() ", dirname, ": ", &strerr_sys);
if(name.a)
stralloc_free(&name);
return -1;
}
/* Ignore everything starting with a . */
if(x->d_name[0] != '.')
{
stralloc_copys(&name, dirname);
stralloc_cats(&name, "/");
stralloc_cats(&name, x->d_name);
stralloc_0(&name);
if(stat(name.s, &st) == -1)
{
strerr_warn2("can't stat ", name.s, &strerr_sys);
}
if(S_ISFIFO(st.st_mode))
{
oaw_func(name.s, sa);
}
else
{
buffer_puts(buffer_2, "ddnsd: warning: ");
buffer_puts(buffer_2, name.s);
buffer_puts(buffer_2, " is no fifo, ignoring\n");
buffer_flush(buffer_2);
}
}
}
closedir(dir);
return 0;
}
int string_quote (stralloc *sa, char const *s, unsigned int len)
{
unsigned int base = sa->len ;
int wasnull = !sa->s ;
if (!stralloc_catb(sa, "\"", 1)) return 0 ;
if (!string_quote_nodelim(sa, s, len) || !stralloc_catb(sa, "\"", 1))
{
if (wasnull) stralloc_free(sa) ; else sa->len = base ;
return 0 ;
}
return 1 ;
}
int s6dns_analyze_record_strings (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start)
{
stralloc sa = STRALLOC_ZERO ;
char buf[rr->rdlength] ;
unsigned int pos = start ;
register int r = s6dns_message_get_strings(buf, rr->rdlength, packet, packetlen, &pos) ;
if (r < 0) return 0 ;
if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ;
if (!string_quote(&sa, buf, r)) return 0 ;
r = (*gp->put)(gp->target, sa.s, sa.len) >= 0 ;
stralloc_free(&sa) ;
return r ;
}
static void
free_service (aa_service *s)
{
genalloc_free (int, &s->needs);
genalloc_free (int, &s->wants);
genalloc_free (int, &s->after);
aa_service_status_free (&s->st);
if (s->fd_out > 0)
close_fd (s->fd_out);
if (s->fd_progress > 0)
close_fd (s->fd_progress);
stralloc_free (&s->sa_out);
}
int ftrig1_make (ftrig1 *f, char const *path)
{
ftrig1 ff = FTRIG1_ZERO ;
unsigned int pathlen = str_len(path) ;
int e = 0 ;
char tmp[pathlen + 46 + FTRIG1_PREFIXLEN] ;
byte_copy(tmp, pathlen, path) ;
tmp[pathlen] = '/' ; tmp[pathlen+1] = '.' ;
byte_copy(tmp + pathlen + 2, FTRIG1_PREFIXLEN, FTRIG1_PREFIX) ;
tmp[pathlen + 2 + FTRIG1_PREFIXLEN] = ':' ;
if (!timestamp(tmp + pathlen + 3 + FTRIG1_PREFIXLEN)) return 0 ;
tmp[pathlen + 28 + FTRIG1_PREFIXLEN] = ':' ;
if (random_name(tmp + pathlen + 29 + FTRIG1_PREFIXLEN, 16) < 16) return 0 ;
tmp[pathlen + 45 + FTRIG1_PREFIXLEN] = 0 ;
{
mode_t m = umask(0) ;
if (fifo_make(tmp, S_IRUSR|S_IWUSR|S_IWGRP|S_IWOTH) == -1)
{
umask(m) ;
return 0 ;
}
umask(m) ;
}
if (!stralloc_catb(&ff.name, tmp, pathlen+1)) { e = errno ; goto err0 ; }
if (!stralloc_catb(&ff.name, tmp + pathlen + 2, FTRIG1_PREFIXLEN + 44))
{
e = errno ; goto err1 ;
}
ff.fd = open_read(tmp) ;
if (ff.fd == -1) { e = errno ; goto err1 ; }
ff.fdw = open_write(tmp) ;
if (ff.fdw == -1) { e = errno ; goto err2 ; }
if (rename(tmp, ff.name.s) == -1) goto err3 ;
*f = ff ;
return 1 ;
err3:
e = errno ;
fd_close(ff.fdw) ;
err2:
fd_close(ff.fd) ;
err1:
stralloc_free(&ff.name) ;
err0:
unlink(tmp) ;
errno = e ;
return 0 ;
}
static int makeuniquename (stralloc *sa, char const *path, char const *magic)
{
unsigned int base = sa->len ;
int wasnull = !sa->s ;
if (!stralloc_cats(sa, path)) return 0 ;
if (!stralloc_cats(sa, magic)) goto err ;
if (random_sauniquename(sa, 8) == -1) goto err ;
if (!stralloc_0(sa)) goto err ;
return 1 ;
err:
if (wasnull) stralloc_free(sa) ; else sa->len = base ;
return 0 ;
}
void unixmessage_receiver_free (unixmessage_receiver_t *b)
{
register unsigned int h = b->maindata.len ;
b->fd = -1 ;
stralloc_free(&b->maindata) ;
h = h != b->mainlen || b->auxdata.len != b->auxlen || cbuffer_len(&b->auxb) ;
if (h)
{
register unsigned int n = b->auxdata.len / sizeof(int) ;
while (n--) fd_close(((int *)b->auxdata.s)[n]) ;
}
stralloc_free(&b->auxdata) ;
if (h)
{
register unsigned int n = cbuffer_len(&b->auxb) / sizeof(int) ;
if (n)
{
int fds[n] ;
cbuffer_get(&b->auxb, (char *)fds, n * sizeof(int)) ;
while (n--) fd_close(fds[n]) ;
}
}
}
void el_substandrun_str (stralloc *src, unsigned int srcbase, char const *const *envp, exlsn_t const *info)
{
stralloc dst = STRALLOC_ZERO ;
register int r = el_substitute(&dst, src->s + srcbase, src->len, info->vars.s, info->values.s, genalloc_s(elsubst_t const, &info->data), genalloc_len(elsubst_t const, &info->data)) ;
if (r < 0) strerr_diefu1sys(111, "el_substitute") ;
if (!r) _exit(0) ;
stralloc_free(src) ;
{
char const *v[r + 1] ;
if (!env_make(v, r, dst.s, dst.len)) strerr_diefu1sys(111, "env_make") ;
v[r] = 0 ;
pathexec_r(v, envp, env_len(envp), info->modifs.s, info->modifs.len) ;
}
strerr_dieexec(111, dst.s) ;
}
int mkdir_unique (stralloc *sa, char const *fn, unsigned int mode)
{
unsigned int base = sa->len ;
int wasnull = !sa->s ;
if (!stralloc_cats(sa, fn)) return 0 ;
if (!stralloc_cats(sa, "/mkdir_unique")) goto fail ;
if (random_sauniquename(sa, 8) < 0) goto fail ;
if (!stralloc_0(sa)) goto fail ;
if (mkdir(sa->s + base, mode) < 0) goto fail ;
sa->len-- ;
return 1 ;
fail:
if (wasnull) stralloc_free(sa) ;
else sa->len = base ;
return 0 ;
}
int s6rc_sanitize_dir (stralloc *sa, char const *fn, unsigned int *dirlen)
{
int wasnull = !sa->s ;
unsigned int base = sa->len ;
unsigned int fnlen = str_len(fn) ;
unsigned int ddirlen ;
if (!sadirname(sa, fn, fnlen)) return 0 ;
if (sa->len != base + 1 || sa->s[base] != '/')
if (!stralloc_catb(sa, "/", 1)) goto err ;
ddirlen = sa->len ;
if (!sabasename(sa, fn, fnlen)) goto err ;
*dirlen = ddirlen ;
return 1 ;
err:
if (wasnull) stralloc_free(sa) ;
else sa->len = base ;
return 0 ;
}
/* evaluates backquoted command list, while writing stdout to a stralloc
* ----------------------------------------------------------------------- */
union node *expand_command(struct nargcmd *cmd, union node **nptr, int flags) {
union node *n = *nptr;
struct vartab vars;
struct fd fd;
struct fdstack fdst;
struct env sh;
stralloc sa;
stralloc_init(&sa);
/* do this in a new i/o context so we can redirect stdout */
vartab_push(&vars);
/* make the output buffer write to the stralloc */
fdstack_push(&fdst);
fd_push(&fd, STDOUT_FILENO, FD_WRITE);
fd_subst(&fd, &sa);
/* evaluate the command tree in a subshell */
sh_push(&sh);
sh_subshell(cmd->list, E_EXIT);
sh_pop(&sh);
fdstack_pop(&fdst);
vartab_pop(&vars);
/* split trailing newlines */
while(sa.len && sa.s[sa.len - 1] == '\n')
sa.len--;
/* expand the output of the command
FIXME: we could do this much nicer by doing an
expand_write() which is set as buffer op
on the output fd.
so we won't have to alloc all the stuff twice!
*/
n = expand_cat(sa.s, sa.len, nptr, flags);
stralloc_free(&sa);
return n;
}
void unixmessage_sender_free (unixmessage_sender_t *b)
{
unsigned int n = genalloc_len(int, &b->fds) ;
if (n)
{
unsigned int i = genalloc_s(diuint, &b->offsets)[b->head].right ;
for (; i < n ; i++)
{
register int fd = genalloc_s(int, &b->fds)[i] ;
if (fd < 0) fd_close(-(fd+1)) ;
#ifdef SKALIBS_HASANCILAUTOCLOSE
else fd_close(fd) ;
#endif
}
}
genalloc_free(diuint, &b->offsets) ;
genalloc_free(int, &b->fds) ;
stralloc_free(&b->data) ;
*b = unixmessage_sender_zero ;
}
/* set a variable
* ----------------------------------------------------------------------- */
struct var *var_set(char *v, int flags) {
struct var *var;
/* find/create the variable */
if((var = var_create(v, flags)) == NULL)
return var;
/* free if it was a previously allocated string */
if(var->sa.a)
stralloc_free(&var->sa);
stralloc_init(&var->sa);
var->sa.s = v;
var->sa.len = str_len(v);
var->offset = var->len;
if(var->len < var->sa.len)
var->offset++;
return var;
}
char *whirlpool_digest(const char *str)
{
whirlpool_t ctx;
stralloc_t sa;
char *buf;
uint8_t digest[DIGESTBYTES];
int i;
whirlpool_init(&ctx);
whirlpool_add(&ctx, (const unsigned char * const) str, str_len(str)*8);
whirlpool_finalize(&ctx, digest);
stralloc_init(&sa);
for (i = 0; i < DIGESTBYTES; i++)
stralloc_catf(&sa, "%02X", digest[i]);
buf = stralloc_finalize(&sa);
stralloc_free(&sa);
return buf;
}
int
dir_type(struct dir_s* d) {
int r = 0;
#if !USE_READDIR && (defined(_WIN32) || defined(_WIN32) || defined(__MSYS__))
if(dir_INTERNAL(d)->dir_finddata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
r |= D_SYMLINK;
else if(dir_INTERNAL(d)->dir_finddata.dwFileAttributes & 0x10)
r |= D_DIRECTORY;
else if(dir_INTERNAL(d)->dir_finddata.dwFileAttributes & 0x20)
r |= D_FILE;
#else
#ifndef DT_DIR
#define DT_DIR 4
#endif
#ifndef DT_REG
#define DT_REG 8
#endif
#ifndef DT_LNK
#define DT_LNK 10
#endif
#if defined(_DIRENT_HAVE_D_TYPE) || (!defined(__MSYS__) && !defined(__CYGWIN__))
switch((dir_TYPE(d))) {
case DT_DIR: {
r |= D_DIRECTORY;
break;
}
case DT_REG: {
r |= D_FILE;
break;
}
case DT_LNK: {
r |= D_SYMLINK;
break;
}
case 0:
default: { break; }
}
#else
{
stralloc sa;
struct stat st;
DIR* dh = dir_INTERNAL(d)->dir_handle;
stralloc_init(&sa);
dir_path(d, &sa);
stralloc_nul(&sa);
if(lstat(sa.s, &st) != -1) {
if(S_ISLNK(st.st_mode))
r |= D_SYMLINK;
else if(S_ISDIR(st.st_mode))
r |= D_DIRECTORY;
else if(S_ISREG(st.st_mode))
r |= D_FILE;
}
#ifdef DEBUG_OUTPUT
buffer_puts(buffer_2, "dir_type path: ");
buffer_putsa(buffer_2, &sa);
buffer_putnlflush(buffer_2);
#endif
// printf("dh: %p __d_dirname: %s\n", dh, dh->__d_dirname);
stralloc_free(&sa);
}
//#error No dirent type method
#endif
#endif
return r;
}
union node*
expand_param(struct nargparam* param, union node** nptr, struct vartab* varstack, char* argv[], int exitcode, int flags) {
union node* n = *nptr;
stralloc value;
char* str = NULL;
const char *v = NULL;
unsigned long argc, vlen = 0;
for(argc = 0; argv[argc]; ++argc)
;
stralloc_init(&value);
/* treat special arguments */
if(param->flag & S_SPECIAL) {
switch(param->flag & S_SPECIAL) {
/* $# substitution */
case S_ARGC: {
stralloc_catulong0(&value, argc, 0);
break;
}
/* $* substitution */
case S_ARGV: {
char** s;
for(s = argv; *s;) {
stralloc_cats(&n->narg.stra, *s);
if(*++s) stralloc_catc(&n->narg.stra, ' ');
}
break;
}
/* $@ substitution */
case S_ARGVS: {
unsigned int i = 0;
while(i < argc) {
param->flag &= ~S_SPECIAL;
param->flag |= S_ARG;
param->numb = 1 + i;
n = expand_param(param, nptr, varstack, argv, exitcode,flags);
if(++i < argc) nptr = &n->list.next;
}
return n;
}
/* $? substitution */
case S_EXITCODE: {
stralloc_catulong0(&value, exitcode, 0);
break;
}
/* $- substitution */
case S_FLAGS: break;
/* $! substitution */
case S_BGEXCODE:
break;
/* $[0-9] arg subst */
case S_ARG: {
if(param->numb == 0) {
/* stralloc_cats(&value, sh_argv0); */
} else if(param->numb - 1 < argc) {
stralloc_cats(&value, argv[param->numb - 1]);
}
break;
}
/* $$ arg subst */
case S_PID: {
stralloc_catulong0(&value, getpid(), 0);
break;
}
}
/* special parameters are always set */
if(value.len) {
stralloc_nul(&value);
v = value.s;
}
vlen = value.len;
}
/* ..and variable substitutions */
else {
size_t offset;
/* look for the variable.
if the S_NULL flag is set and we have a var which is null
set v to NULL */
if((v = var_get(varstack, param->name, &offset))) {
if(v[offset] == '\0' && (param->flag & S_NULL)) {
v = NULL;
vlen = 0;
} else {
v = &v[offset];
vlen = str_len(v);
}
}
}
/* check for S_STRLEN substitution */
if(param->flag & S_STRLEN) {
char lstr[FMT_ULONG];
n = expand_cat(lstr, fmt_ulong(lstr, vlen), nptr, varstack, flags);
stralloc_free(&value);
return n;
}
str = str_ndup(v, vlen);
/* otherwise expand the apropriate variable/word subst */
switch(param->flag & S_VAR) {
/* return word if parameter unset (or null) */
case S_DEFAULT: {
if(v) n = expand_cat(v, vlen, nptr, varstack, flags);
/* unset, substitute */
else
n = expand_arg(¶m->word->narg, nptr, varstack, argv, exitcode, flags);
break;
}
/* if parameter unset (or null) then expand word to it
and substitute paramter */
case S_ASGNDEF: {
if(v)
n = expand_cat(v, vlen, nptr, varstack, flags);
else {
n = expand_arg(¶m->word->narg, nptr, varstack, argv, exitcode, flags | X_NOSPLIT);
var_setvsa(param->name, /* BUG */ &n->narg.stra, V_DEFAULT);
}
break;
}
/* indicate error if null or unset */
case S_ERRNULL: {
if(v)
n = expand_cat(v, vlen, nptr, varstack, flags);
else {
union node* tmpnode = NULL;
n = expand_arg(¶m->word->narg, &tmpnode, varstack, argv, exitcode, flags);
errmsg_warn((n && n->narg.stra.s) ? n->narg.stra.s : "parameter null or not set", 0);
if(tmpnode) tree_free(tmpnode);
}
break;
}
/* if parameter unset (or null) then substitute null,
otherwise substitute word */
case S_ALTERNAT: {
if(v) n = expand_arg(¶m->word->narg, nptr, varstack, argv, exitcode, flags);
break;
/* remove smallest matching suffix */
case S_RSSFX: {
int i;
stralloc sa;
if(v && vlen) {
expand_copysa(param->word, &sa, varstack, argv, exitcode, 0);
stralloc_nul(&sa);
for(i = vlen - 1; i >= 0; i--)
if(fnmatch(sa.s, str + i, FNM_PERIOD) == 0) break;
n = expand_cat(v, (i < 0 ? vlen : i), nptr, varstack, flags);
}
break;
}
}
/* remove largest matching suffix */
case S_RLSFX: {
unsigned int i;
stralloc sa;
if(v && vlen) {
expand_copysa(param->word, &sa, varstack, argv, exitcode, 0);
stralloc_nul(&sa);
for(i = 0; i <= vlen; i++)
if(fnmatch(sa.s, str + i, FNM_PERIOD) == 0) break;
n = expand_cat(v, (i > vlen ? vlen : i), nptr, varstack, flags);
}
break;
}
/* remove smallest matching prefix */
case S_RSPFX: {
unsigned int i;
stralloc sa;
if(v && vlen) {
expand_copysa(param->word, &sa, varstack, argv, exitcode, 0);
stralloc_nul(&sa);
for(i = 1; i <= vlen; i++) {
str_copyn(str, v, i);
if(fnmatch(sa.s, (char*)v, FNM_PERIOD) == 0) break;
}
if(i > vlen) i = 0;
n = expand_cat(v + i, vlen - i, nptr, varstack, flags);
str_copy(str, v);
}
break;
}
/* remove largest matching prefix */
case S_RLPFX: {
unsigned int i;
stralloc sa;
if(v && vlen) {
expand_copysa(param->word, &sa, varstack, argv, exitcode, 0);
stralloc_nul(&sa);
for(i = vlen; i > 0; i--) {
str_copyn(str, v, i);
if(fnmatch(sa.s, (char*)v, FNM_PERIOD) == 0) break;
}
if(i == 0) i = vlen;
n = expand_cat(v + i, vlen - i, nptr, varstack, flags);
str_copy(str, v);
}
break;
}
}
free(str);
stralloc_free(&value);
return n;
}
int main (int argc, char const *const *argv)
{
unsigned int count = 0 ;
flags_t flags = FLAGS_ZERO ;
PROG = "s6-grep" ;
{
subgetopt_t l = SUBGETOPT_ZERO ;
for (;;)
{
register int opt = subgetopt_r(argc, argv, "Fcnqv", &l) ;
if (opt == -1) break ;
switch (opt)
{
case 'F': flags.fixed = 1 ; break ;
case 'c': flags.count = 1 ; break ;
case 'n': flags.num = 1 ; break ;
case 'q': flags.quiet = 1 ; break ;
case 'v': flags.not = 1 ; break ;
default : strerr_dieusage(100, USAGE) ;
}
}
argc -= l.ind ; argv += l.ind ;
}
if (!argc) strerr_dieusage(100, USAGE) ;
{
stralloc line = STRALLOC_ZERO ;
struct sredfa *re = 0 ;
unsigned int num = 0 ;
unsigned int arglen = 0 ;
if (flags.fixed) arglen = str_len(argv[0]) ;
else
{
re = sredfa_new() ;
if (!re) strerr_diefu1sys(111, "sredfa_new") ;
if (!sredfa_from_regexp(re, argv[0]))
strerr_diefu1sys(111, "compile regular expression") ;
}
for (;;)
{
register int r ;
line.len = 0 ;
r = skagetln(buffer_0f1, &line, '\n') ;
if (!r) break ;
if (r < 0)
{
if ((errno != EPIPE) || !stralloc_catb(&line, "\n", 1))
strerr_diefu1sys(111, "read from stdin") ;
}
num++ ;
r = flags.fixed ?
(str_strn(line.s, line.len-1, argv[0], arglen) < line.len - 1) :
sredfa_match(re, line.s, line.len-1) ;
if (r < 0)
{
int e = errno ;
buffer_flush(buffer_1) ;
errno = e ;
strerr_diefu1sys(111, "match line against pattern") ;
}
if (r ^ flags.not)
{
count++ ;
if (!flags.quiet && !flags.count)
{
if (flags.num)
{
char fmt[UINT_FMT] ;
register unsigned int n = uint_fmt(fmt, num) ;
fmt[n++] = ':' ;
if (buffer_putalign(buffer_1, fmt, n) < (int)n)
strerr_diefu1sys(111, "write to stdout") ;
}
if (buffer_putalign(buffer_1, line.s, line.len) < (int)line.len)
strerr_diefu1sys(111, "write to stdout") ;
}
}
}
if (flags.quiet) return !count ;
stralloc_free(&line) ;
if (!flags.fixed) sredfa_delete(re) ;
}
if (flags.count)
{
char fmt[UINT_FMT] ;
register unsigned int n = uint_fmt(fmt, count) ;
fmt[n++] = '\n' ;
if (buffer_putalign(buffer_1, fmt, n) < (int)n)
strerr_diefu1sys(111, "write to stdout") ;
}
return !count ;
}
int
main (int argc, char * const argv[])
{
PROG = "aa-start";
const char *path_repo = "/run/services";
const char *path_list = NULL;
int i;
aa_secs_timeout = DEFAULT_TIMEOUT_SECS;
for (;;)
{
struct option longopts[] = {
{ "double-output", no_argument, NULL, 'D' },
{ "help", no_argument, NULL, 'h' },
{ "listdir", required_argument, NULL, 'l' },
{ "dry-list", no_argument, NULL, 'n' },
{ "repodir", required_argument, NULL, 'r' },
{ "timeout", required_argument, NULL, 't' },
{ "version", no_argument, NULL, 'V' },
{ "verbose", no_argument, NULL, 'v' },
{ "no-wants", no_argument, NULL, 'W' },
{ NULL, 0, 0, 0 }
};
int c;
c = getopt_long (argc, argv, "Dhl:nr:t:VvW", longopts, NULL);
if (c == -1)
break;
switch (c)
{
case 'D':
aa_set_double_output (1);
break;
case 'h':
dieusage (0);
case 'l':
unslash (optarg);
path_list = optarg;
break;
case 'n':
if (mode & AA_MODE_IS_DRY)
mode |= AA_MODE_IS_DRY_FULL;
else
mode |= AA_MODE_IS_DRY;
break;
case 'r':
unslash (optarg);
path_repo = optarg;
break;
case 't':
if (!uint0_scan (optarg, &aa_secs_timeout))
aa_strerr_diefu2sys (ERR_IO, "set default timeout to ", optarg);
break;
case 'V':
aa_die_version ();
case 'v':
verbose = 1;
break;
case 'W':
no_wants = 1;
break;
default:
dieusage (1);
}
}
argc -= optind;
argv += optind;
cols = get_cols (1);
is_utf8 = is_locale_utf8 ();
if (!path_list && argc < 1)
dieusage (1);
if (aa_init_repo (path_repo, (mode & AA_MODE_IS_DRY) ? AA_REPO_READ : AA_REPO_WRITE) < 0)
aa_strerr_diefu2sys (ERR_IO, "init repository ", path_repo);
if (path_list)
{
stralloc sa = STRALLOC_ZERO;
int r;
if (*path_list != '/' && *path_list != '.')
stralloc_cats (&sa, LISTDIR_PREFIX);
stralloc_catb (&sa, path_list, strlen (path_list) + 1);
r = aa_scan_dir (&sa, 1, it_start, NULL);
stralloc_free (&sa);
if (r < 0)
aa_strerr_diefu3sys (-r, "read list directory ",
(*path_list != '/' && *path_list != '.') ? LISTDIR_PREFIX : path_list,
(*path_list != '/' && *path_list != '.') ? path_list : "");
}
tain_now_g ();
for (i = 0; i < argc; ++i)
if (str_equal (argv[i], "-"))
{
if (process_names_from_stdin ((names_cb) add_service, NULL) < 0)
aa_strerr_diefu1sys (ERR_IO, "process names from stdin");
}
else
add_service (argv[i], NULL);
mainloop (mode, scan_cb);
if (!(mode & AA_MODE_IS_DRY))
{
aa_bs_noflush (AA_OUT, "\n");
put_title (1, PROG, "Completed.", 1);
aa_show_stat_nb (nb_already, "Already up", ANSI_HIGHLIGHT_GREEN_ON);
aa_show_stat_nb (nb_done, "Started", ANSI_HIGHLIGHT_GREEN_ON);
show_stat_service_names (&ga_timedout, "Timed out", ANSI_HIGHLIGHT_RED_ON);
show_stat_service_names (&ga_failed, "Failed", ANSI_HIGHLIGHT_RED_ON);
show_stat_service_names (&ga_depend, "Dependency failed", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_io, "I/O error", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_unknown, "Unknown", ANSI_HIGHLIGHT_RED_ON);
aa_show_stat_names (aa_names.s, &ga_skipped, "Skipped", ANSI_HIGHLIGHT_YELLOW_ON);
}
genalloc_free (int, &ga_timedout);
genalloc_free (int, &ga_failed);
genalloc_free (int, &ga_depend);
genalloc_free (size_t, &ga_io);
genalloc_free (size_t, &ga_unknown);
genalloc_free (size_t, &ga_skipped);
genalloc_free (pid_t, &ga_pid);
genalloc_free (int, &aa_tmp_list);
genalloc_free (int, &aa_main_list);
stralloc_free (&aa_names);
genalloc_deepfree (struct progress, &ga_progress, free_progress);
aa_free_services (close_fd);
genalloc_free (iopause_fd, &ga_iop);
return rc;
}
int
main (int argc, char * const argv[])
{
PROG = "aa-kill";
for (;;)
{
struct option longopts[] = {
{ "double-output", no_argument, NULL, 'D' },
{ "help", no_argument, NULL, 'h' },
{ "kill", no_argument, NULL, 'k' },
{ "skip-at", no_argument, NULL, 's' },
{ "term", no_argument, NULL, 't' },
{ "hup", no_argument, NULL, 'u' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, 0, 0 }
};
int c;
c = getopt_long (argc, argv, "DhkstuV", longopts, NULL);
if (c == -1)
break;
switch (c)
{
case 'D':
aa_set_double_output (1);
break;
case 'h':
dieusage (0);
case 'k':
send.kill = 1;
break;
case 's':
send.skip_at = 1;
break;
case 't':
send.term = 1;
break;
case 'u':
send.hup = 1;
break;
case 'V':
aa_die_version ();
default:
dieusage (1);
}
}
argc -= optind;
argv += optind;
if (argc > 0 || (!send.hup && !send.term && !send.kill))
dieusage (1);
if (send.skip_at)
{
stralloc sa = STRALLOC_ZERO;
unsigned int u;
u = (unsigned int) getpid ();
ownpid[uint_fmt (ownpid, u)] = '\0';
if (!stralloc_catb (&sa, "/proc", sizeof ("/proc")))
aa_strerr_diefu1sys (1, "stralloc_catb");
if (aa_scan_dir (&sa, 0, it_kill, &sa) < 0)
aa_strerr_diefu1sys (1, "scan /proc");
stralloc_free (&sa);
}
else
{
if (send.hup)
{
sig_ignore (SIGHUP);
_kill (-1, SIGHUP);
}
if (send.term)
{
sig_ignore (SIGTERM);
_kill (-1, SIGTERM);
_kill (-1, SIGCONT);
}
if (send.kill)
_kill (-1, SIGKILL);
}
return 0;
}
/* change working directory
* ----------------------------------------------------------------------- */
int builtin_cd(int argc, char **argv) {
int c;
int ok = 0;
int symbolic = 1;
const char *arg;
unsigned long len;
unsigned long n;
stralloc newcwd;
/* check options, -L for symlink, -P for physical path */
while((c = shell_getopt(argc, argv, "LP")) > 0) {
switch(c) {
case 'L': symbolic = 1; break;
case 'P': symbolic = 0; break;
default: builtin_invopt(argv); return 1;
}
}
arg = argv[shell_optind];
stralloc_init(&newcwd);
/* empty argument means chdir(HOME) */
if(arg == NULL) {
arg = var_value("HOME", &len);
if(arg[0] == '\0') {
sh_msg("HOME variable not set!");
return 1;
}
}
len = str_len(arg);
/* when it isn't an absolute path we have to check CDPATH */
if(arg[0] != '/') {
char path[PATH_MAX + 1];
const char *cdpath;
/* loop through colon-separated CDPATH variable */
cdpath = var_value("CDPATH", NULL);
do {
/* too much, too much :) */
if((n = str_chr(cdpath, ':')) + len + 1 > PATH_MAX) {
/* set error code and print the longer string in the error msg */
errno = ENAMETOOLONG;
return builtin_errmsgn(argv, (n > len ? cdpath : arg),
(n > len ? n : len), strerror(errno));
}
/* copy path prefix from cdpath if present */
if(n) {
byte_copy(path, n, cdpath);
cdpath += n;
path[n++] = '/';
}
/* copy the argument and canonicalize */
str_copy(&path[n], arg);
ok = shell_realpath(path, &newcwd, symbolic, &sh->cwd);
/* skip the colon */
if(*cdpath == ':')
cdpath++;
} while(*cdpath && !ok);
}
/* absolute path */
else {
/* last cdpath length set to 0, because we're not using cdpath here */
n = 0;
ok = shell_canonicalize(arg, &newcwd, symbolic);
}
stralloc_nul(&newcwd);
/* try to chdir() if everything's ok */
if(ok && chdir(newcwd.s) == 0) {
/* print path if prefix was taken from cdpath */
if(n) {
buffer_putsa(fd_out->w, &newcwd);
buffer_putnlflush(fd_out->w);
}
/* set the path */
stralloc_move(&sh->cwd, &newcwd);
/* if the path has symlinks then set sh->cwdsym */
sh->cwdsym = (ok > 1);
return 0;
}
/* we failed */
builtin_error(argv, newcwd.s);
stralloc_free(&newcwd);
return 1;
}
