int main(int argc, const char *const *argv) {
jmp_buf ejbuf;
void (*actionfunction)(const char *const *argv);
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
standard_startup(&ejbuf);
loadcfgfile(DPKG, cmdinfos);
myopt(&argv, cmdinfos);
if (!cipaction) badusage(_("need an action option"));
if (!f_triggers)
f_triggers = (cipaction->arg == act_triggers && *argv) ? -1 : 1;
setvbuf(stdout, NULL, _IONBF, 0);
if (is_invoke_action(cipaction->arg))
run_invoke_hooks(cipaction->olong, pre_invoke_hooks);
filesdbinit();
actionfunction= (void (*)(const char* const*))cipaction->farg;
actionfunction(argv);
if (is_invoke_action(cipaction->arg))
run_invoke_hooks(cipaction->olong, post_invoke_hooks);
standard_shutdown();
return reportbroken_retexitstatus();
}
int main(int argc, const char *const *argv) {
struct dpkg_error err;
int ret;
setlocale(LC_NUMERIC, "POSIX");
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
dpkg_set_progname(BACKEND);
standard_startup();
myopt(&argv, cmdinfos, printforhelp);
if (!cipaction) badusage(_("need an action option"));
if (!compressor_check_params(&compress_params, &err))
badusage(_("invalid compressor parameters: %s"), err.str);
unsetenv("GZIP");
ret = cipaction->action(argv);
standard_shutdown();
return ret;
}
int
main(int argc, const char *const *argv)
{
int uf;
const char *badname;
enum trigdef_updateflags tduf;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
dpkg_set_progname("dpkg-trigger");
standard_startup();
myopt(&argv, cmdinfos, printforhelp);
admindir = dpkg_db_set_dir(admindir);
setvbuf(stdout, NULL, _IONBF, 0);
if (f_check) {
if (*argv)
badusage(_("--%s takes no arguments"),
"check-supported");
do_check();
}
if (!*argv || argv[1])
badusage(_("takes one argument, the trigger name"));
badname = parse_awaiter_package();
if (badname)
ohshit(_("illegal awaited package name '%.250s': %.250s"),
bypackage, badname);
activate = argv[0];
badname = trig_name_is_illegal(activate);
if (badname)
badusage(_("invalid trigger name `%.250s': %.250s"),
activate, badname);
trigdef_set_methods(&tdm_add);
tduf = tduf_nolockok;
if (!f_noact)
tduf |= tduf_write | tduf_writeifempty;
uf = trigdef_update_start(tduf);
if (uf >= 0) {
trigdef_parse();
if (!done_trig)
trigdef_update_printf("%s %s\n", activate, bypackage);
trigdef_process_done();
}
standard_shutdown();
return 0;
}
main(int argc, char *argv[]) {
int x;
char optarray[256];
//char outarray[256][256];
char *argument;
char *argument2;
argus *arglist;
argument = calloc(256,1);
argument2 = calloc(256,1);
//memset(argument,0,256);
//memset(argument2,0,256);
memset(optarray,0,sizeof(optarray)); /* This is important! */
arglist = calloc(1,sizeof(arglist));
/* myopt takes an array of letters with :'s following if it*/
/* requires a parameter */
/* vvvvvvvvvvvvvvvvvvvvvvvvv*/
strcpy(optarray,"k:f:x:pac:w:");
printf("%s\n",optarray);
myopt(optarray,argc,argv,arglist);
/* Lets make find_arg find the parameter for an option letter */
/* that we specify on the command line.*/
/* ie "./clo -w x -x Stuff" will stick Stuff in argument2 */
argument = find_arg(arglist,'w');
/* Is this the best way to check for required options? */
if (argument == NULL) {
printf("w not found\n");
exit(0);
}
printf("argument = %s\n",argument);
argument2 = find_arg(arglist,argument[0]);
printf("argument2 = %s\n",argument2);
return 0;
}
void commandfd(const char *const *argv) {
jmp_buf ejbuf;
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);
if (setjmp(ejbuf)) { /* expect warning about possible clobbering of argv */
error_unwind(ehflag_bombout); exit(2);
}
for (;;) {
bool mode = false;
int argc= 1;
lno= 0;
push_error_handler(&ejbuf, print_error_fatal, NULL);
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++;
if (isspace(c)) argc++; /* This isn't fully accurate, but overestimating can't hurt. */
} 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]);
cipaction= NULL;
myopt((const char *const**)&newargs,cmdinfos);
if (!cipaction) badusage(_("need an action option"));
actionfunction= (void (*)(const char* const*))cipaction->farg;
actionfunction(newargs);
set_error_display(NULL, NULL);
error_unwind(ehflag_normaltidy);
}
}
