static void list_verbs(int one_per_line)
{
fprintf(stderr, "known verbs:\n");
list_keys(hda_verbs, one_per_line);
fprintf(stderr, "known parameters:\n");
list_keys(hda_params, one_per_line);
}
void call_py_fkt()
{
try
{
py::object sys = py::import("sys");
py::dict sysdict = py::extract<py::dict>(sys.attr("__dict__"));
py::list path = py::extract<py::list>(sysdict["path"]);
path.append(".");
py::object mod = py::import("sqw");
py::dict moddict = py::extract<py::dict>(mod.attr("__dict__"));
py::object Sqw = moddict["TakinSqw"];
for(double dE=0.; dE<1.; dE+=0.1)
{
double dS = py::extract<double>(Sqw(1., 1., 1., dE));
std::cout << dS << std::endl;
}
py::object mn = py::import("__main__");
py::dict mndict = py::extract<py::dict>(mn.attr("__dict__"));
std::cout << "\nmain dict:\n";
list_keys(mndict);
//std::cout << "\nsys dict:\n";
//list_keys(sysdict);
std::cout << "\nmod dict:\n";
list_keys(moddict);
}
catch(const py::error_already_set& ex)
{
PyErr_Print();
PyErr_Clear();
}
}
/*
* List all keys on a keyring
*/
static int list_keyring(const char *keyring)
{
key_serial_t key;
key = find_key_by_type_and_desc("keyring", keyring, 0);
if (key == -1) {
xlog_err("'%s' keyring was not found.", keyring);
return EXIT_FAILURE;
}
list_keys(keyring, key);
return EXIT_SUCCESS;
}
void main(int argc, char *argv[])
{
if(argc < 2)
{
printf("Usage : ssignal [KEY_X]\n");
printf("To see available keys use : -h\n");
return;
}
if(strncmp(argv[1],"-h",2)==0)
{
list_keys();
return;
}
press_button(atoi(argv[1]));
}
int execute_program(int argc, char **argv)
{
switch(string_to_key(argv[1]))
{
case OUTPUTPID: return do_outputPID();
case OUTPUTIDS: return do_outputIDs();
case SIMPLEFORK: return do_simplefork();
case TWOPROCS: return do_twoprocs();
case BADPROCESSID: return do_badprocessID();
case SIMPLECHAIN: return do_simplechain(argc, argv);
case SIMPLEFAN: return do_simplefan(argc, argv);
case FANWAIT: return do_fanwait(argc, argv);
case PARENTWAITPID: return do_parentwaitpid();
case FANWAITMSG: return do_fanwaitmsg(argc, argv);
case CHAINWAITMSG: return do_chainwaitmsg(argc, argv);
case EXECLS: return do_execls();
case EXECCMD: return do_execcmd(argc, argv);
case EXECCMDARGV: return do_execcmdargv(argc, argv);
case RUNBACK: return do_runback(argc, argv);
case SIMPLECOPY: return do_simplecopy();
case COPYFILE: return do_copyfile(argc, argv);
case MONITORFORK: return do_monitorfork(argc, argv);
case PARENTPIPE: return do_parentwritepipe();
case SYNCFAN: return do_synchronizefan(argc, argv);
case SIMPLEREDIR: return do_simpleredirect();
case PCFIFO: return do_parentchildfifo(argc, argv);
case PIPESERVER: return do_pipeserver(argc, argv);
case PIPECLIENT: return do_pipeclient(argc, argv);
case RING: return ring(argc, argv);
case MAILBOXAPP: return do_mailboxapp(argc, argv);
case LISTKEYS: return list_keys();
case BADKEY:
printf("Invalid Key!\r\n");
return BADKEY;
}
return -1;
}
int main(int argc, char *argv[])
{
PKCS11_CTX *ctx=NULL;
PKCS11_SLOT *slots=NULL, *slot;
PKCS11_KEY *keys;
unsigned int nslots, nkeys;
char password[20];
int rc = 0;
if (argc < 2) {
fprintf(stderr,
"usage: %s /usr/lib/opensc-pkcs11.so [PIN]\n",
argv[0]);
return 1;
}
ctx = PKCS11_CTX_new();
error_queue("PKCS11_CTX_new");
/* load pkcs #11 module */
rc = PKCS11_CTX_load(ctx, argv[1]);
error_queue("PKCS11_CTX_load");
CHECK_ERR(rc < 0, "loading pkcs11 engine failed", 1);
/* get information on all slots */
rc = PKCS11_enumerate_slots(ctx, &slots, &nslots);
error_queue("PKCS11_enumerate_slots");
CHECK_ERR(rc < 0, "no slots available", 2);
/* get first slot with a token */
slot = PKCS11_find_token(ctx, slots, nslots);
error_queue("PKCS11_find_token");
CHECK_ERR(!slot || !slot->token, "no token available", 3);
printf("Slot manufacturer......: %s\n", slot->manufacturer);
printf("Slot description.......: %s\n", slot->description);
printf("Slot token label.......: %s\n", slot->token->label);
printf("Slot token manufacturer: %s\n", slot->token->manufacturer);
printf("Slot token model.......: %s\n", slot->token->model);
printf("Slot token serialnr....: %s\n", slot->token->serialnr);
/* get public keys */
rc = PKCS11_enumerate_public_keys(slot->token, &keys, &nkeys);
error_queue("PKCS11_enumerate_public_keys");
CHECK_ERR(rc < 0, "PKCS11_enumerate_public_keys failed", 4);
CHECK_ERR(nkeys == 0, "No public keys found", 5);
list_keys("Public keys", keys, nkeys);
if (slot->token->loginRequired && argc > 2) {
strcpy(password, argv[2]);
/* perform pkcs #11 login */
rc = PKCS11_login(slot, 0, password);
error_queue("PKCS11_login");
memset(password, 0, strlen(password));
CHECK_ERR(rc < 0, "PKCS11_login failed", 6);
}
/* get private keys */
rc = PKCS11_enumerate_keys(slot->token, &keys, &nkeys);
error_queue("PKCS11_enumerate_keys");
CHECK_ERR(rc < 0, "PKCS11_enumerate_keys failed", 7);
CHECK_ERR(nkeys == 0, "No private keys found", 8);
list_keys("Private keys", keys, nkeys);
end:
if (slots)
PKCS11_release_all_slots(ctx, slots, nslots);
if (ctx) {
PKCS11_CTX_unload(ctx);
PKCS11_CTX_free(ctx);
}
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
if (rc)
printf("Failed (error code %d).\n", rc);
else
printf("Success.\n");
return rc;
}
int
main(int argc, char *argv[])
{
int c, nostop=0;
char *h;
int i_rc = 0;
cd_operation_t cd_op = NO_OP; /* operation to do in non-interactive mode */
psz_program = strrchr(argv[0],'/');
psz_program = psz_program ? psz_program+1 : argv[0];
memset(&cddb_opts, 0, sizeof(cddb_opts));
cdio_loglevel_default = CDIO_LOG_WARN;
/* parse options */
while ( 1 ) {
if (-1 == (c = getopt(argc, argv, "acCdehkplL:sSt:vx")))
break;
switch (c) {
case 'v':
b_verbose = true;
if (cdio_loglevel_default > CDIO_LOG_INFO)
cdio_loglevel_default = CDIO_LOG_INFO;
break;
case 'd':
debug = 1;
if (cdio_loglevel_default > CDIO_LOG_DEBUG)
cdio_loglevel_default = CDIO_LOG_DEBUG;
break;
case 'a':
auto_mode = 1;
break;
case 'L':
i_volume_level = atoi(optarg);
cd_op = SET_VOLUME;
b_interactive = false;
break;
case 't':
if (NULL != (h = strchr(optarg,'-'))) {
*h = 0;
start_track = atoi(optarg);
stop_track = atoi(h+1)+1;
if (0 == start_track) start_track = 1;
if (1 == stop_track) stop_track = CDIO_CDROM_LEADOUT_TRACK;
} else {
start_track = atoi(optarg);
stop_track = start_track+1;
one_track = 1;
}
b_interactive = false;
cd_op = PLAY_TRACK;
break;
case 'p':
b_interactive = false;
cd_op = PLAY_CD;
break;
case 'l':
b_interactive = false;
cd_op = LIST_TRACKS;
break;
case 'C':
b_interactive = false;
cd_op = CLOSE_CD;
break;
case 'c':
b_interactive = false;
cd_op = PS_LIST_TRACKS;
break;
case 's':
b_interactive = false;
cd_op = STOP_PLAYING;
break;
case 'S':
b_interactive = false;
cd_op = LIST_SUBCHANNEL;
break;
case 'e':
b_interactive = false;
cd_op = EJECT_CD;
break;
case 'k':
print_keys();
exit(1);
case 'h':
usage(psz_program);
exit(1);
default:
usage(psz_program);
exit(1);
}
}
if (argc > optind) {
psz_device = strdup(argv[optind]);
} else {
char **ppsz_cdda_drives=NULL;
char **ppsz_all_cd_drives = cdio_get_devices_ret(&driver_id);
if (!ppsz_all_cd_drives) {
fprintf(stderr, "Can't find a CD-ROM drive\n");
exit(2);
}
ppsz_cdda_drives = cdio_get_devices_with_cap(ppsz_all_cd_drives,
CDIO_FS_AUDIO, false);
if (!ppsz_cdda_drives || !ppsz_cdda_drives[0]) {
fprintf(stderr, "Can't find a CD-ROM drive with a CD-DA in it\n");
exit(3);
}
psz_device = strdup(ppsz_cdda_drives[0]);
cdio_free_device_list(ppsz_all_cd_drives);
cdio_free_device_list(ppsz_cdda_drives);
}
if (!b_interactive) {
b_sig = true;
nostop=1;
}
tty_raw();
signal(SIGINT,ctrlc);
signal(SIGQUIT,ctrlc);
signal(SIGTERM,ctrlc);
signal(SIGHUP,ctrlc);
signal(SIGWINCH, sigwinch);
if (CLOSE_CD != cd_op) {
/* open device */
if (b_verbose)
fprintf(stderr, "open %s... ", psz_device);
p_cdio = cdio_open (psz_device, driver_id);
if (!p_cdio && cd_op != EJECT_CD) {
cd_close(psz_device);
p_cdio = cdio_open (psz_device, driver_id);
}
if (p_cdio && b_verbose)
fprintf(stderr,"ok\n");
}
if (b_interactive) {
#ifdef HAVE_CDDB
cddb_log_set_handler (cddb_log_handler);
#else
;
#endif
} else {
b_sig = true;
nostop=1;
if (EJECT_CD == cd_op) {
i_rc = cd_eject() ? 0 : 1;
} else {
switch (cd_op) {
case PS_LIST_TRACKS:
case LIST_TRACKS:
case PLAY_TRACK:
read_toc(p_cdio);
default:
break;
}
if (p_cdio)
switch (cd_op) {
case STOP_PLAYING:
b_cd = true;
i_rc = cd_stop(p_cdio) ? 0 : 1;
break;
case EJECT_CD:
/* Should have been handled above. */
cd_eject();
break;
case LIST_TRACKS:
list_tracks();
break;
case PS_LIST_TRACKS:
ps_list_tracks();
break;
case PLAY_TRACK:
/* play just this one track */
if (b_record) {
printf("%s / %s\n", artist, title);
if (one_track)
printf("%s\n", cd_info[start_track].title);
}
i_rc = play_track(start_track, stop_track) ? 0 : 1;
break;
case PLAY_CD:
if (b_record)
printf("%s / %s\n", artist, title);
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case SET_VOLUME:
i_rc = set_volume_level(p_cdio, i_volume_level);
break;
case LIST_SUBCHANNEL:
if (read_subchannel(p_cdio)) {
if (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY) {
{
printf("track %2d - %02x:%02x (%02x:%02x abs) ",
sub.track, sub.rel_addr.m, sub.rel_addr.s,
sub.abs_addr.m, sub.abs_addr.s);
}
}
printf("drive state: %s\n",
mmc_audio_state2str(sub.audio_status));
} else {
i_rc = 1;
}
break;
case CLOSE_CD: /* Handled below */
case LIST_KEYS:
case TOGGLE_PAUSE:
case EXIT_PROGRAM:
case NO_OP:
break;
}
else if (CLOSE_CD == cd_op) {
i_rc = (DRIVER_OP_SUCCESS == cdio_close_tray(psz_device, NULL))
? 0 : 1;
} else {
fprintf(stderr,"no CD in drive (%s)\n", psz_device);
}
}
}
/* Play all tracks *unless* we have a play or paused status
already. */
read_subchannel(p_cdio);
if (sub.audio_status != CDIO_MMC_READ_SUB_ST_PAUSED &&
sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY)
play_track(1, CDIO_CDROM_LEADOUT_TRACK);
while ( !b_sig ) {
int key;
if (!b_cd) read_toc(p_cdio);
read_subchannel(p_cdio);
display_status(false);
if (1 == select_wait(b_cd ? 1 : 5)) {
switch (key = getch()) {
case '-':
decrease_volume_level(p_cdio);
break;
case '+':
increase_volume_level(p_cdio);
break;
case 'A':
case 'a':
auto_mode = !auto_mode;
break;
case 'X':
case 'x':
nostop=1;
/* fall through */
case 'Q':
case 'q':
b_sig = true;
break;
case 'E':
case 'e':
cd_eject();
break;
case 's':
cd_stop(p_cdio);
break;
case 'C':
case 'c':
cd_close(psz_device);
break;
case 'L':
case 'l':
b_all_tracks = !b_all_tracks;
if (b_all_tracks)
display_tracks();
else {
i_last_display_track = CDIO_INVALID_TRACK;
display_cdinfo(p_cdio, i_tracks, i_first_track);
}
break;
case 'K':
case 'k':
case 'h':
case 'H':
case '?':
list_keys();
break;
case ' ':
case 'P':
case 'p':
toggle_pause();
break;
case KEY_RIGHT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track+1, CDIO_CDROM_LEADOUT_TRACK);
else
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_LEFT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track-1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_UP:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(10);
break;
case KEY_DOWN:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(-10);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
play_track(key - '0', CDIO_CDROM_LEADOUT_TRACK);
break;
case '0':
play_track(10, CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_F(1):
case KEY_F(2):
case KEY_F(3):
case KEY_F(4):
case KEY_F(5):
case KEY_F(6):
case KEY_F(7):
case KEY_F(8):
case KEY_F(9):
case KEY_F(10):
case KEY_F(11):
case KEY_F(12):
case KEY_F(13):
case KEY_F(14):
case KEY_F(15):
case KEY_F(16):
case KEY_F(17):
case KEY_F(18):
case KEY_F(19):
case KEY_F(20):
play_track(key - KEY_F(1) + 11, CDIO_CDROM_LEADOUT_TRACK);
break;
}
}
}
if (!nostop) cd_stop(p_cdio);
tty_restore();
finish("bye", i_rc);
return 0; /* keep compiler happy */
}
int main(void) {
char line[MAX_LINE];
entry *entryHead; //head of entry list
snapshot *snapHead; //head of snapshot list
entryHead = NULL;
snapHead = NULL;
while (true) {
printf("> ");
if (fgets(line, MAX_LINE, stdin) == NULL) {
printf("\n");
command_bye(entryHead, snapHead);
return 0;
}
//get command from the input line as well as a second parameter if it exists
char *ptr = strtok(line, " ");
char firstToken[MAX_COMMAND]; //stores a command
strcpy(firstToken, ptr);
ptr = strtok(NULL, " ");
char secondToken[MAX_KEY]; //stores either a key or a second part of the command
secondToken[0] = '\0';
//get rid of a new line character if it exists in the last valid token entered
char *newLine;
if (ptr != NULL) {
strcpy(secondToken, ptr);
newLine = strchr(secondToken, '\n');
}
else {
newLine = strchr(firstToken, '\n');
}
if (newLine) {
*newLine = 0;
}
//identify the command and call the right function to execute the command entered
if (strcasecmp(firstToken, "BYE") == 0) {
command_bye(entryHead, snapHead);
return 0;
}
else if (strcasecmp(firstToken, "HELP") == 0) {
command_help();
}
else if (strcasecmp(firstToken, "LIST") == 0) {
if (strcasecmp(secondToken, "ENTRIES") == 0) {
list_entries(entryHead);
}
else if (strcasecmp(secondToken, "KEYS") == 0) {
list_keys(entryHead);
}
else if(strcasecmp(secondToken, "SNAPSHOTS") == 0) {
list_snapshots(snapHead);
}
else {
printf("unknown\n");
}
}
else if (strcasecmp(firstToken, "GET") == 0) {
get(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "DEL") == 0) {
entryHead = del(entryHead, secondToken);
}
else if (strcasecmp(firstToken, "PURGE") == 0) {
entryHead = purge(secondToken, entryHead, snapHead);
}
else if (strcasecmp(firstToken, "SET") == 0) {
if (ptr != NULL && secondToken[0] != '\0') {
entryHead = set(ptr, secondToken, entryHead);
}
else {
printf("invalid input\n");
}
}
else if (strcasecmp(firstToken, "PUSH") == 0 || strcasecmp(firstToken, "APPEND") == 0) {
push_append(ptr, secondToken, entryHead, firstToken);
}
else if (strcasecmp(firstToken, "PICK") == 0) {
ptr = strtok(NULL, " ");
int index = atoi(ptr);
pick(index, secondToken, entryHead);
}
else if (strcasecmp(firstToken, "PLUCK") == 0) {
ptr = strtok(NULL, " ");
int index = atoi(ptr);
pluck(index, secondToken, entryHead);
}
else if (strcasecmp(firstToken, "POP") == 0) {
pluck(1, secondToken, entryHead);
}
else if (strcasecmp(firstToken, "DROP") == 0) {
snapHead = drop(snapHead, atoi(secondToken));
}
else if (strcasecmp(firstToken, "ROLLBACK") == 0) {
entryHead = checkout(atoi(secondToken), entryHead, snapHead);
snapHead = remove_snapshots(atoi(secondToken), snapHead);
}
else if (strcasecmp(firstToken, "CHECKOUT") == 0) {
entryHead = checkout(atoi(secondToken), entryHead, snapHead);
}
else if (strcasecmp(firstToken, "SNAPSHOT") == 0) {
snapHead = take_snapshot(entryHead, snapHead);
}
else if (strcasecmp(firstToken, "MIN") == 0) {
min(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "MAX") == 0) {
max(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "SUM") == 0) {
sum(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "LEN") == 0) {
len(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "REV") == 0) {
reverse(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "UNIQ") == 0) {
unique(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "SORT") == 0) {
sort(secondToken, entryHead);
}
else if (strcasecmp(firstToken, "DIFF") == 0) {
diff(ptr, secondToken, entryHead);
}
else if (strcasecmp(firstToken, "INTER") == 0) {
inter(ptr, secondToken, entryHead);
}
else if (strcasecmp(firstToken, "UNION") == 0) {
union_oper(ptr, secondToken, entryHead);
}
else {
printf("unknown\n");
}
printf("\n");
}
return 0;
}
int
main(int argc, char *argv[])
{
const char *ifname, *cmd;
unsigned char bnounit = 0;
char *if_base = NULL;
unsigned int unit_res = -1;
int res = 0;
if (argc < 2 ||
strncmp(argv[1],"-h",2) == 0 || strncmp(argv[1],"--h",3) == 0)
usage();
ifname = argv[1];
if (argc == 2) {
ieee80211_status(ifname);
return 0;
}
cmd = argv[2];
if (streq(cmd, "create")) {
struct ieee80211_clone_params cp;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
memset(&cp, 0, sizeof(cp));
strncpy(cp.icp_name, ifname, IFNAMSIZ);
/* NB: station mode is the default */
cp.icp_opmode = IEEE80211_M_STA;
/* NB: default is to request a unique bssid/mac */
cp.icp_flags = IEEE80211_CLONE_BSSID;
while (argc > 3) {
if (strcmp(argv[3], "wlanmode") == 0) {
if (argc < 5)
usage();
cp.icp_opmode = (u_int16_t) getopmode(argv[4]);
argc--;
argv++;
} else if (strcmp(argv[3], "wlandev") == 0) {
if (argc < 5)
usage();
strncpy(ifr.ifr_name, argv[4], IFNAMSIZ);
argc--;
argv++;
} else if (strcmp(argv[3], "nounit" ) == 0) {
bnounit = 1;
} else {
int flag = getflag(argv[3]);
if (flag < 0)
cp.icp_flags &= ~(-flag);
else
cp.icp_flags |= flag;
}
argc--;
argv++;
}
if (ifr.ifr_name[0] == '\0')
errx(1, "no device specified with wlandev");
res = if_split_name(cp.icp_name, &if_base, &unit_res);
if (res < 0) {
err(1, "if_split_name() - malloc");
} else if ((res == 0) && (bnounit == 0)) {
/* user gave a string only and using a unit */
unit_res = if_find_unit(if_base);
if (unit_res < 0) {
err(1, "if_find_unit - failed");
} else {
snprintf(cp.icp_name + strlen(if_base),
IFNAMSIZ - strlen(if_base), "%d", unit_res);
}
}
free(if_base);
if_base = NULL;
ifr.ifr_data = (void *) &cp;
vap_create(&ifr);
printf("%s\n", ifr.ifr_name);
} else if (streq(cmd, "destroy")) {
vap_destroy(ifname);
} else if (streq(cmd, "list")) {
if (argc > 3) {
const char *arg = argv[3];
if (streq(arg, "sta"))
list_stations(ifname);
else if (streq(arg, "scan") || streq(arg, "ap"))
list_scan(ifname);
else if (streq(arg, "chan") || streq(arg, "freq"))
list_channels(ifname, 1);
else if (streq(arg, "active"))
list_channels(ifname, 0);
else if (streq(arg, "keys"))
list_keys(ifname);
else if (streq(arg, "caps"))
list_capabilities(ifname);
else if (streq(arg, "wme"))
list_wme(ifname);
else
err(1, "unknown 'list' option: %s", arg);
} else /* NB: for compatibility */
list_stations(ifname);
} else
usage();
return 0;
}
