void
RSA_free(RSA *rsa)
{
if (rsa->references <= 0)
abort();
if (--rsa->references > 0)
return;
(*rsa->meth->finish)(rsa);
if (rsa->engine)
ENGINE_finish(rsa->engine);
#define free_if(f) if (f) { BN_free(f); }
free_if(rsa->n);
free_if(rsa->e);
free_if(rsa->d);
free_if(rsa->p);
free_if(rsa->q);
free_if(rsa->dmp1);
free_if(rsa->dmq1);
free_if(rsa->iqmp);
#undef free_if
memset(rsa, 0, sizeof(*rsa));
free(rsa);
}
/**
* Free an allocation RSA object.
*
* @param rsa the RSA object to free.
*/
void
RSA_free(RSA *rsa)
{
if (rsa->references <= 0) {
abort();
}
if (--rsa->references > 0) { /* XXX replace w/ atomic op */
return;
}
(*rsa->meth->finish)(rsa);
if (rsa->engine) {
ENGINE_finish(rsa->engine);
}
#define free_if(f) if (f) { BN_clear_free(f); }
free_if(rsa->n);
free_if(rsa->e);
free_if(rsa->d);
free_if(rsa->p);
free_if(rsa->q);
free_if(rsa->dmp1);
free_if(rsa->dmq1);
free_if(rsa->iqmp);
#undef free_if
memset(rsa, 0, sizeof(*rsa));
free(rsa);
}
void
DH_free(DH *dh)
{
if (dh->references <= 0)
abort();
if (--dh->references > 0)
return;
(*dh->meth->finish)(dh);
if (dh->engine)
ENGINE_finish(dh->engine);
#define free_if(f) if (f) { BN_free(f); }
free_if(dh->p);
free_if(dh->g);
free_if(dh->pub_key);
free_if(dh->priv_key);
free_if(dh->q);
free_if(dh->j);
free_if(dh->counter);
#undef free_if
memset(dh, 0, sizeof(*dh));
free(dh);
}
void
DSA_free(DSA *dsa)
{
if (dsa->references <= 0)
abort();
if (--dsa->references > 0)
return;
(*dsa->meth->finish)(dsa);
#define free_if(f) if (f) { BN_free(f); }
free_if(dsa->p);
free_if(dsa->q);
free_if(dsa->g);
free_if(dsa->pub_key);
free_if(dsa->priv_key);
free_if(dsa->kinv);
free_if(dsa->r);
#undef free_if
memset(dsa, 0, sizeof(*dsa));
free(dsa);
}
static void
free_stmt(PLpgSQL_stmt *stmt)
{
switch ((enum PLpgSQL_stmt_types) stmt->cmd_type)
{
case PLPGSQL_STMT_BLOCK:
free_block((PLpgSQL_stmt_block *) stmt);
break;
case PLPGSQL_STMT_ASSIGN:
free_assign((PLpgSQL_stmt_assign *) stmt);
break;
case PLPGSQL_STMT_IF:
free_if((PLpgSQL_stmt_if *) stmt);
break;
case PLPGSQL_STMT_CASE:
free_case((PLpgSQL_stmt_case *) stmt);
break;
case PLPGSQL_STMT_LOOP:
free_loop((PLpgSQL_stmt_loop *) stmt);
break;
case PLPGSQL_STMT_WHILE:
free_while((PLpgSQL_stmt_while *) stmt);
break;
case PLPGSQL_STMT_FORI:
free_fori((PLpgSQL_stmt_fori *) stmt);
break;
case PLPGSQL_STMT_FORS:
free_fors((PLpgSQL_stmt_fors *) stmt);
break;
case PLPGSQL_STMT_FORC:
free_forc((PLpgSQL_stmt_forc *) stmt);
break;
case PLPGSQL_STMT_FOREACH_A:
free_foreach_a((PLpgSQL_stmt_foreach_a *) stmt);
break;
case PLPGSQL_STMT_EXIT:
free_exit((PLpgSQL_stmt_exit *) stmt);
break;
case PLPGSQL_STMT_RETURN:
free_return((PLpgSQL_stmt_return *) stmt);
break;
case PLPGSQL_STMT_RETURN_NEXT:
free_return_next((PLpgSQL_stmt_return_next *) stmt);
break;
case PLPGSQL_STMT_RETURN_QUERY:
free_return_query((PLpgSQL_stmt_return_query *) stmt);
break;
case PLPGSQL_STMT_RAISE:
free_raise((PLpgSQL_stmt_raise *) stmt);
break;
case PLPGSQL_STMT_ASSERT:
free_assert((PLpgSQL_stmt_assert *) stmt);
break;
case PLPGSQL_STMT_EXECSQL:
free_execsql((PLpgSQL_stmt_execsql *) stmt);
break;
case PLPGSQL_STMT_DYNEXECUTE:
free_dynexecute((PLpgSQL_stmt_dynexecute *) stmt);
break;
case PLPGSQL_STMT_DYNFORS:
free_dynfors((PLpgSQL_stmt_dynfors *) stmt);
break;
case PLPGSQL_STMT_GETDIAG:
free_getdiag((PLpgSQL_stmt_getdiag *) stmt);
break;
case PLPGSQL_STMT_OPEN:
free_open((PLpgSQL_stmt_open *) stmt);
break;
case PLPGSQL_STMT_FETCH:
free_fetch((PLpgSQL_stmt_fetch *) stmt);
break;
case PLPGSQL_STMT_CLOSE:
free_close((PLpgSQL_stmt_close *) stmt);
break;
case PLPGSQL_STMT_PERFORM:
free_perform((PLpgSQL_stmt_perform *) stmt);
break;
default:
elog(ERROR, "unrecognized cmd_type: %d", stmt->cmd_type);
break;
}
}
int main(int argc, char *argv[])
{
int x, y, z, m, v4args, v6args, argcount;
struct if_info *ifarg_start, *ifarg_cur;
int ch, parse_stdin;
struct misc_args m_argv4, m_argv6;
int split_errv4, split_errv6, range_err;
char oldcmdstr[ARGLEN] = "";
struct argbox *abox_start, *abox_cur, *abox_tmp;
char *stdinarg[3];
ident = progname(argv[0]);
if (argc < 2)
return usage(1);
parse_stdin = 0;
/*
* Our default v4 and v6 options, hopefully what's mostly used.
*/
v4args = V4_INFO;
v6args = V6_INFO;
m_argv4.splitmask = 0;
m_argv4.numnets = 0;
m_argv4.range_min = 0;
m_argv4.range_max = 0;
m_argv6.splitmask = 0;
m_argv6.numnets = 0;
split_errv4 = 0;
split_errv6 = 0;
range_err = 0;
ifarg_start = NULL;
/*
* abox == argument box == a box that holds (commandline) arguments :)
* This is the structure we use to store all user input parsed into
* (hopefully) manageable chunks.
* This excludes most of the -[a-z] flags, they're generally handled by
* v[4,6]args.
*/
abox_start = abox_cur = (struct argbox *)calloc(1, sizeof(struct argbox));
/*
* v[4,6]args holds flags based on commandline arguments for what we
* want to output.
*/
while ((ch = getopt(argc, argv, "cehnrR:s:S:v")) != -1) {
switch (ch) {
case 'c':
v4args |= V4CHECK;
v6args |= V6CHECK;
break;
case 'e':
v6args |= V4INV6;
break;
case 'n':
colorize = 0;
break;
case 'r':
v6args |= V6REV;
break;
case 'R':
y = getrange_min_max(optarg, &m_argv4.range_min, &m_argv4.range_max);
if (!y) {
v4args |= V4RANGE;
} else {
warnx("Invalid Range MIN:MAX values, required MIN > 0 and MIN < MAX.");
range_err = 1;
}
break;
case 's':
y = getsplitnumv4(optarg, &m_argv4.splitmask);
if (!y) {
v4args |= V4SPLIT;
} else {
warnx("Invalid IPv4 splitmask, unable to split.");
split_errv4 = 1;
}
break;
case 'S':
y = getsplitnumv6(optarg, &m_argv6.v6splitmask, &m_argv6.v6splitnum);
if (!y) {
v6args |= V6SPLIT;
} else {
warnx("Invalid IPv6 splitmask, unable to split.");
split_errv6 = 1;
}
break;
case 'v':
printf("%s\n", VERSION);
return 0;
case '?':
case 'h':
return usage(0);
default:
return usage(1);
}
}
if (!isatty(STDIN_FILENO) || !isatty(STDOUT_FILENO))
colorize = 0;
if (split_errv4 || split_errv6 || range_err) {
nothing:
warnx("No (valid) commands received, nothing to do.");
free_boxargs(abox_start);
return 1;
}
argcount = optind;
if (m_argv4.numnets < 1)
m_argv4.numnets = -1;
if (argv[argcount]) {
if (argv[argcount][0] == '-' && argv[argcount][1] == '\0')
parse_stdin = 1;
} else {
if (abox_start->str[0] == '\0') {
free_boxargs(abox_start);
return usage(0);
}
}
/*
* Populate our argumentbox.
* (Ie., see what's on the commandline).
*/
if (!parse_stdin && argv[argcount]) {
abox_cur = get_boxargs(argc, argv, argcount, abox_cur);
abox_tmp = abox_start;
while (abox_tmp->next != abox_cur) {
abox_tmp = abox_tmp->next;
}
abox_tmp->next = NULL;
free(abox_cur);
abox_cur = NULL;
}
/*
* This will try to gather information about the network interfaces
* present on the local machine.
*/
if (!parse_stdin)
ifarg_cur = ifarg_start = parse_abox(abox_start);
if (!ifarg_start && !parse_stdin)
goto nothing;
ifarg_cur = ifarg_start;
while (ifarg_cur && !parse_stdin) {
out_cmdline(ifarg_cur, v4args, m_argv4, v6args, m_argv6);
strlcpy(oldcmdstr, ifarg_cur->cmdstr, sizeof(oldcmdstr));
ifarg_cur = ifarg_cur->next;
}
z = 0;
y = 1;
while (parse_stdin && y > -1) {
stdinarg[0] = (char *)calloc(1, ARGLEN);
stdinarg[1] = (char *)calloc(1, ARGLEN);
stdinarg[2] = NULL;
y = get_stdin(stdinarg);
if (y > 0) {
m = 2;
if (stdinarg[1][0] == '\0') {
free(stdinarg[1]);
stdinarg[1] = NULL;
m = 1;
}
abox_cur = get_boxargs(m, stdinarg, 0, abox_cur);
abox_tmp = abox_start;
while (abox_tmp->next != abox_cur && abox_tmp != abox_cur) {
abox_tmp = abox_tmp->next;
}
abox_tmp->next = NULL;
free(abox_cur);
abox_cur = NULL;
ifarg_cur = ifarg_start = parse_abox(abox_start);
if (ifarg_start) {
ifarg_cur = ifarg_start;
while (ifarg_cur) {
out_cmdline(ifarg_cur, v4args, m_argv4, v6args, m_argv6);
strlcpy(oldcmdstr, ifarg_cur->cmdstr, sizeof(oldcmdstr));
ifarg_cur = ifarg_cur->next;
}
}
z = 1;
free_if(ifarg_start);
free_boxargs(abox_start);
abox_start = abox_cur = (struct argbox *)calloc(1, sizeof(struct argbox));
}
for (x = 0; x < 2; x++) {
if (stdinarg[x]) {
free(stdinarg[x]);
stdinarg[x] = NULL;
}
}
if (y == -1)
warnx("Problem parsing stdin");
}
if (parse_stdin) {
free(stdinarg[0]);
free(stdinarg[1]);
}
if (!z && parse_stdin)
warnx("No arguments found on stdin");
if (!parse_stdin)
free_if(ifarg_start);
return 0;
}
