int printf_main(int argc, char **argv) { char *format; int args_used; if (argc <= 1 || argv[1][0] == '-') { bb_show_usage(); } format = argv[1]; argc -= 2; argv += 2; do { args_used = print_formatted(format, argc, argv); argc -= args_used; argv += args_used; } while (args_used > 0 && argc > 0); /* if (argc > 0) fprintf(stderr, "excess args ignored"); */ return EXIT_SUCCESS; }
void generate_sentence(char * element) { list_nodeT * curr_node, * production = NULL; production = get_non_terminal_random_production(element); if(production == NULL ) { printf("ERROR!"); fprintf(stderr, "ERROR: No production found for the '%s' non terminal element.\nQuiting...\n", element); exit(-1); } curr_node = walk_list(production); while ( production != curr_node ) { char * token = curr_node->content; if (is_non_terminal(token)) { generate_sentence(token); } else { print_formatted(token); } curr_node = walk_list(curr_node); } return; }
int printf_main(int argc UNUSED_PARAM, char **argv) { char *format; char **argv2; /* We must check that stdout is not closed. * The reason for this is highly non-obvious. * printf_main is used from shell. * Shell must correctly handle 'printf "%s" foo' * if stdout is closed. With stdio, output gets shoveled into * stdout buffer, and even fflush cannot clear it out. It seems that * even if libc receives EBADF on write attempts, it feels determined * to output data no matter what. So it will try later, * and possibly will clobber future output. Not good. */ // TODO: check fcntl() & O_ACCMODE == O_WRONLY or O_RDWR? if (fcntl(1, F_GETFL) == -1) return 1; /* match coreutils 6.10 (sans error msg to stderr) */ //if (dup2(1, 1) != 1) - old way // return 1; /* bash builtin errors out on "printf '-%s-\n' foo", * coreutils-6.9 works. Both work with "printf -- '-%s-\n' foo". * We will mimic coreutils. */ if (argv[1] && argv[1][0] == '-' && argv[1][1] == '-' && !argv[1][2]) argv++; if (!argv[1]) { if (ENABLE_ASH_BUILTIN_PRINTF && applet_name[0] != 'p' ) { bb_error_msg("usage: printf FORMAT [ARGUMENT...]"); return 2; /* bash compat */ } bb_show_usage(); } format = argv[1]; argv2 = argv + 2; do { argv = argv2; argv2 = print_formatted(format, argv); } while (argv2 > argv && *argv2); /* coreutils compat (bash doesn't do this): if (*argv) fprintf(stderr, "excess args ignored"); */ return (argv2 < argv); /* if true, print_formatted errored out */ }
static void doit(struct libusb20_device *dev) { int rv; if (do_request) printf("doit(): bmRequestType 0x%02x, bRequest 0x%02x, wValue 0x%04x, wIndex 0x%04x, wLength 0x%04x\n", setup.bmRequestType, setup.bRequest, setup.wValue, setup.wIndex, setup.wLength); /* * Open the device, allocating memory for two possible (bulk or * interrupt) transfers. * * If only control transfers are intended (via * libusb20_dev_request_sync()), transfer_max can be given as 0. */ if ((rv = libusb20_dev_open(dev, 1)) != 0) { fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv)); return; } /* * If the device has more than one configuration, select the desired * one here. */ if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0) { fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv)); return; } uint8_t *data = 0; uint16_t actlen; if ((setup.bmRequestType & 0x80) != 0) { /* this is an IN request, allocate a buffer */ data = malloc(setup.wLength); if (data == 0) { fprintf(stderr, "Out of memory allocating %u bytes of reply buffer\n", setup.wLength); return; } } else data = out_buf; if (do_request) { if ((rv = libusb20_dev_request_sync(dev, &setup, data, &actlen, TIMEOUT, 0 /* flags */)) != 0) { fprintf(stderr, "libusb20_dev_request_sync: %s\n", libusb20_strerror(rv)); } printf("sent %d bytes\n", actlen); if ((setup.bmRequestType & 0x80) != 0) { print_formatted(data, (uint32_t)setup.wLength); free(data); } } if (intr_ep != 0) { /* * One transfer has been requested in libusb20_dev_open() above; * obtain the corresponding transfer struct pointer. */ struct libusb20_transfer *xfr_intr = libusb20_tr_get_pointer(dev, 0); if (xfr_intr == NULL) { fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv)); return; } /* * Open the interrupt transfer. */ if ((rv = libusb20_tr_open(xfr_intr, 0, 1, intr_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } uint8_t in_buf[BUFLEN]; uint32_t rlen; if ((rv = libusb20_tr_bulk_intr_sync(xfr_intr, in_buf, BUFLEN, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv)); } printf("received %d bytes\n", rlen); if (rlen > 0) print_formatted(in_buf, rlen); libusb20_tr_close(xfr_intr); } libusb20_dev_close(dev); }
static void doit(struct libusb20_device *dev) { int rv; /* * Open the device, allocating memory for two possible (bulk or * interrupt) transfers. * * If only control transfers are intended (via * libusb20_dev_request_sync()), transfer_max can be given as 0. */ if ((rv = libusb20_dev_open(dev, 2)) != 0) { fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv)); return; } /* * If the device has more than one configuration, select the desired * one here. */ if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0) { fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv)); return; } /* * Two transfers have been requested in libusb20_dev_open() above; * obtain the corresponding transfer struct pointers. */ struct libusb20_transfer *xfr_out = libusb20_tr_get_pointer(dev, 0); struct libusb20_transfer *xfr_in = libusb20_tr_get_pointer(dev, 1); if (xfr_in == NULL || xfr_out == NULL) { fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv)); return; } /* * Open both transfers, the "out" one for the write endpoint, the * "in" one for the read endpoint (ep | 0x80). */ if ((rv = libusb20_tr_open(xfr_out, 0, 1, out_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } if ((rv = libusb20_tr_open(xfr_in, 0, 1, in_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } uint8_t in_buf[BUFLEN]; uint32_t rlen; if (out_len > 0) { if ((rv = libusb20_tr_bulk_intr_sync(xfr_out, out_buf, out_len, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync (OUT): %s\n", libusb20_strerror(rv)); } printf("sent %d bytes\n", rlen); } if ((rv = libusb20_tr_bulk_intr_sync(xfr_in, in_buf, BUFLEN, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv)); } printf("received %d bytes\n", rlen); if (rlen > 0) print_formatted(in_buf, rlen); libusb20_tr_close(xfr_out); libusb20_tr_close(xfr_in); libusb20_dev_close(dev); }
int main(int argc, char **argv) { char *cmd = parse_cmdline(argc, argv, NOT_GUI); int rc; char buf[BUFLEN]; struct securid_token *t; rc = common_init(cmd); if (rc != ERR_NONE) die("can't initialize: %s\n", stoken_errstr[rc]); t = current_token; if (!t) die("error: no token present. Use 'stoken import' to add one.\n"); terminal_init(); if (!strcmp(cmd, "tokencode")) { int days_left = securid_check_exp(t, adjusted_time()); if (days_left < 0 && !opt_force) die("error: token has expired; use --force to override\n"); unlock_token(t, 1, NULL); securid_compute_tokencode(t, adjusted_time(), buf); puts(buf); if (days_left < 14 && !opt_force) warn("warning: token expires in %d day%s\n", days_left, days_left == 1 ? "" : "s"); } else if (!strcmp(cmd, "import")) { char *pass; unlock_token(t, 0, &pass); if (!opt_keep_password) { pass = xmalloc(BUFLEN); request_new_pass(pass); } t->is_smartphone = 0; securid_encode_token(t, pass, opt_new_devid, buf); rc = write_token_and_pin(buf, NULL, pass); if (rc != ERR_NONE) die("rcfile: error writing new token: %s\n", stoken_errstr[rc]); } else if (!strcmp(cmd, "export")) { char *pass; unlock_token(t, 0, &pass); if (opt_new_password) pass = opt_new_password; else if (!opt_keep_password) pass = NULL; t->is_smartphone = opt_iphone || opt_android; securid_encode_token(t, pass, opt_new_devid, buf); print_formatted(buf); } else if (!strcmp(cmd, "show")) { unlock_token(t, 0, NULL); securid_token_info(t, &print_token_info_line); } else if (!strcmp(cmd, "setpin")) { char *pass = NULL, pin[BUFLEN], confirm_pin[BUFLEN]; int len; if (opt_file || opt_token) die("error: setpin only operates on the rcfile token\n"); unlock_token(t, 0, &pass); if (opt_new_pin) { if (securid_pin_format_ok(opt_new_pin) != ERR_NONE) die("error: invalid --new-pin format\n"); strncpy(pin, opt_new_pin, BUFLEN); len = strlen(pin); } else { prompt("Enter new PIN: "); len = read_user_input(pin, BUFLEN, 1); if (len > 0 && securid_pin_format_ok(pin) != ERR_NONE) die("error: PIN must be 4-8 digits\n"); prompt("Confirm new PIN: "); read_user_input(confirm_pin, BUFLEN, 1); if (strcmp(pin, confirm_pin) != 0) die("error: PINs do not match\n"); } securid_encode_token(t, pass, NULL, buf); rc = write_token_and_pin(buf, len ? pin : NULL, pass); free(pass); if (rc != ERR_NONE) die("error: can't set PIN: %s\n", stoken_errstr[rc]); } else if (!strcmp(cmd, "setpass")) { char pass[BUFLEN]; unlock_token(t, 0, NULL); request_new_pass(pass); securid_encode_token(t, pass, NULL, buf); /* just print to stdout if it didn't come from the rcfile */ if (opt_file || opt_token) print_formatted(buf); else { rc = write_token_and_pin(buf, strlen(t->pin) ? t->pin : NULL, strlen(pass) ? pass : NULL); if (rc != ERR_NONE) die("error: can't set password: %s\n", stoken_errstr[rc]); } } else die("error: invalid command '%s'\n", cmd); return 0; }
void parameters::update (parameter_defaults const & pdef, ull_t flag ){ std::vector<std::vector<std::string>> missing; std::vector<std::vector<std::string>> wrong_t; std::vector<std::vector<std::string>> no_deft; std::vector<std::string> desc{"key:", "description:"}; std::vector<std::string> tdesc{"key:", "expected type:", "actual type:"}; if ( (flag & reject_key_without_default) ) { // check that no extra parameters are present for (auto const & pvp : *this) { auto key = pvp.first; if (!pdef.has_key(key)){ no_deft.push_back({key}); } } } for (auto const & pvp : pdef) { auto key = pvp.first; // check whether required parameters are present if (pdef.is_required(key) && (!this->has_key(key))){ // delay exception until all parameters have been checked if (!missing.size()) missing.push_back(desc); missing.push_back({key, pdef.doc(key)}); } if (this->has_key(key)) { // check whether the type is correct if (! have_same_type(pvp.second, (*this)[key])){ // delay exception until all parameters have been checked if (!wrong_t.size()) wrong_t.push_back(tdesc); wrong_t.push_back({key, pvp.second.type_name(), (*this)[key].type_name()}); } } else { (*this)[key] = pvp.second; // insert the default } } // raise a runtime exception if errors occured if(missing.size()) TRIQS_RUNTIME_ERROR << "update with defaults : the following parameters are required but absent: \n"<< print_formatted(missing); if(wrong_t.size()) TRIQS_RUNTIME_ERROR << "update with defaults : the following parameters have incorrect type: \n"<< print_formatted(wrong_t); if(no_deft.size()) TRIQS_RUNTIME_ERROR << "update with defaults : the following parameters are absent from the defaults and no_parameter_without_default is ON: \n"<< print_formatted(no_deft); }