int
main(int argc, char **argv)
{
struct tar_archive tar;
struct tar_context tar_ctx;
const char *tar_name = argv[1];
setvbuf(stdout, NULL, _IOLBF, 0);
push_error_context();
if (tar_name) {
tar_ctx.tar_fd = open(tar_name, O_RDONLY);
if (tar_ctx.tar_fd < 0)
ohshite("cannot open file '%s'", tar_name);
} else {
tar_ctx.tar_fd = STDIN_FILENO;
}
tar.err = DPKG_ERROR_OBJECT;
tar.ctx = &tar_ctx;
tar.ops = &tar_ops;
if (tar_extractor(&tar))
ohshite("extracting tar");
if (tar_name)
close(tar_ctx.tar_fd);
pop_error_context(ehflag_normaltidy);
return 0;
}
/**
* @brief Initialize dpkg and load packages into memory
*/
void dpkg_setup(struct pkg_array *packages) {
dpkg_set_progname("osquery");
push_error_context();
dpkg_db_set_dir("/var/lib/dpkg/");
modstatdb_init();
modstatdb_open(msdbrw_readonly);
pkg_array_init_from_db(packages);
pkg_array_sort(packages, pkg_sorter);
}
int
main(int argc, char **argv)
{
const char *admindir = argv[1];
int ret;
setvbuf(stdout, NULL, _IOLBF, 0);
push_error_context();
if (admindir == NULL)
ohshit("missing triggers deferred admindir");
ret = test_trigdeferred_parser(admindir);
pop_error_context(ehflag_normaltidy);
return ret;
}
int
commandfd(const char *const *argv)
{
struct varbuf linevb = VARBUF_INIT;
const char * pipein;
const char **newargs = NULL;
char *ptr, *endptr;
FILE *in;
long infd;
int ret = 0;
int c, lno, i;
bool skipchar;
pipein = *argv++;
if (pipein == NULL || *argv)
badusage(_("--%s takes exactly one argument"), cipaction->olong);
infd = dpkg_options_parse_arg_int(cipaction, pipein);
in = fdopen(infd, "r");
if (in == NULL)
ohshite(_("couldn't open '%i' for stream"), (int)infd);
for (;;) {
bool mode = false;
int argc= 1;
lno= 0;
push_error_context();
do {
c = getc(in);
if (c == '\n')
lno++;
} while (c != EOF && c_isspace(c));
if (c == EOF) break;
if (c == '#') {
do { c= getc(in); if (c == '\n') lno++; } while (c != EOF && c != '\n');
continue;
}
varbuf_reset(&linevb);
do {
varbuf_add_char(&linevb, c);
c= getc(in);
if (c == '\n') lno++;
/* This isn't fully accurate, but overestimating can't hurt. */
if (c_isspace(c))
argc++;
} while (c != EOF && c != '\n');
if (c == EOF)
ohshit(_("unexpected end of file before end of line %d"), lno);
if (!argc) continue;
varbuf_end_str(&linevb);
newargs = m_realloc(newargs, sizeof(const char *) * (argc + 1));
argc= 1;
ptr= linevb.buf;
endptr = ptr + linevb.used + 1;
skipchar = false;
while(ptr < endptr) {
if (skipchar) {
skipchar = false;
} else if (*ptr == '\\') {
memmove(ptr, (ptr+1), (linevb.used-(linevb.buf - ptr)-1));
endptr--;
skipchar = true;
continue;
} else if (c_isspace(*ptr)) {
if (mode == true) {
*ptr = '\0';
mode = false;
}
} else {
if (mode == false) {
newargs[argc]= ptr;
argc++;
mode = true;
}
}
ptr++;
}
*ptr = '\0';
newargs[argc++] = NULL;
/* We strdup() each argument, but never free it, because the
* error messages contain references back to these strings.
* Freeing them, and reusing the memory, would make those
* error messages confusing, to say the least. */
for(i=1;i<argc;i++)
if (newargs[i])
newargs[i] = m_strdup(newargs[i]);
setaction(NULL, NULL);
dpkg_options_parse((const char *const **)&newargs, cmdinfos, printforhelp);
if (!cipaction) badusage(_("need an action option"));
ret |= cipaction->action(newargs);
pop_error_context(ehflag_normaltidy);
}
return ret;
}
void commandfd(const char *const *argv) {
struct varbuf linevb = VARBUF_INIT;
const char * pipein;
const char **newargs = NULL;
char *ptr, *endptr;
FILE *in;
unsigned long infd;
int c, lno, i;
bool skipchar;
void (*actionfunction)(const char *const *argv);
pipein = *argv++;
if (pipein == NULL)
badusage(_("--command-fd takes one argument, not zero"));
if (*argv)
badusage(_("--command-fd only takes one argument"));
errno = 0;
infd = strtoul(pipein, &endptr, 10);
if (pipein == endptr || *endptr || infd > INT_MAX)
ohshite(_("invalid integer for --%s: `%.250s'"), "command-fd", pipein);
if ((in= fdopen(infd, "r")) == NULL)
ohshite(_("couldn't open `%i' for stream"), (int) infd);
for (;;) {
bool mode = false;
int argc= 1;
lno= 0;
push_error_context();
do { c= getc(in); if (c == '\n') lno++; } while (c != EOF && isspace(c));
if (c == EOF) break;
if (c == '#') {
do { c= getc(in); if (c == '\n') lno++; } while (c != EOF && c != '\n');
continue;
}
varbufreset(&linevb);
do {
varbufaddc(&linevb,c);
c= getc(in);
if (c == '\n') lno++;
/* This isn't fully accurate, but overestimating can't hurt. */
if (isspace(c))
argc++;
} while (c != EOF && c != '\n');
if (c == EOF) ohshit(_("unexpected eof before end of line %d"),lno);
if (!argc) continue;
varbufaddc(&linevb,0);
newargs = m_realloc(newargs, sizeof(const char *) * (argc + 1));
argc= 1;
ptr= linevb.buf;
endptr= ptr + linevb.used;
skipchar = false;
while(ptr < endptr) {
if (skipchar) {
skipchar = false;
} else if (*ptr == '\\') {
memmove(ptr, (ptr+1), (linevb.used-(linevb.buf - ptr)-1));
endptr--;
skipchar = true;
continue;
} else if (isspace(*ptr)) {
if (mode == true) {
*ptr = '\0';
mode = false;
}
} else {
if (mode == false) {
newargs[argc]= ptr;
argc++;
mode = true;
}
}
ptr++;
}
*ptr = '\0';
newargs[argc++] = NULL;
/* We strdup() each argument, but never free it, because the
* error messages contain references back to these strings.
* Freeing them, and reusing the memory, would make those
* error messages confusing, to say the least. */
for(i=1;i<argc;i++)
if (newargs[i])
newargs[i] = m_strdup(newargs[i]);
setaction(NULL, NULL);
myopt((const char *const**)&newargs,cmdinfos);
if (!cipaction) badusage(_("need an action option"));
actionfunction= (void (*)(const char* const*))cipaction->farg;
actionfunction(newargs);
pop_error_context(ehflag_normaltidy);
}
}
