static void test_pushpop() {
size_t nb = (size_t) pasl::util::cmdline::parse_or_default_int64("nb", 35);
Seq s;
printf("------------\nStarting\n");
for (int i = 0; i < nb; i++) {
printf("-------------\nPushing front %d\n", i);
s.push_front(ItemGenerator::from_int(i));
print_seq(s);
s.check();
}
std::cout << "-----" << std::endl;
std::cout << "size=" << s.size() << std::endl;
print_seq(s);
Seq xxx = s;
print_seq(xxx);
std::cout << "-----" << std::endl;
for (int i = nb-1; i >= 0; i--) {
print_seq(s);
printf("-------------\nPopping %s %d\n", ((lifo) ? "front" : "back"), i);
Item r;
if (mode == lifo)
r = s.pop_front();
else
r = s.pop_back();
printf(" =%d\n", ItemGenerator::to_int(r));
ItemGenerator::free(r);
s.check();
}
}
void seq_sum(int sum)
{
if (sum < 2)
{
return;
}
int small = 1, big = 2;
int middle = (1 + sum) >> 2;
int cur_sum = small + big;
while (small < middle)
{
if (cur_sum == sum)
{
print_seq(small, big);
}
while (cur_sum>sum && small<middle)
{
cur_sum -= small;
++small;
if (cur_sum == sum)
{
print_seq(small, big);
}
}
++big;
cur_sum += big;
}
}
void split_psmcfa(int trunk_size, kseq_t *seq)
{
while (kseq_read(seq) >= 0) {
int i, k;
for (i = k = 0; i < seq->seq.l; i += trunk_size) {
if (seq->seq.l - i < trunk_size * 3 / 2) { // use the full length
print_seq(seq, i, seq->seq.l, ++k);
break;
} else print_seq(seq, i, (i+trunk_size < seq->seq.l)? i+trunk_size : seq->seq.l, ++k);
}
}
}
static void test_concat() {
Seq s;
Seq t;
size_t nbs = (size_t) pasl::util::cmdline::parse_or_default_int64("nbs", 2);
size_t nbt = (size_t) pasl::util::cmdline::parse_or_default_int64("nbt", 5);
push(s, nbs, 0);
print_seq(s);
push(t, nbt, nbs);
print_seq(t);
s.concat(t);
printf("ok\n");
print_seq(s);
printf("ok\n");
s.check();
}
void tests() {
auto end = node(s("end"));
auto middle = node(s("middle"), end);
auto beginning = node(s("beginning"), middle);
end->next = beginning;
beginning->print_seq();
//remove middle node
beginning->next = beginning->next->next;
beginning->print_seq();
//insert a node
auto new_middle = node(s("new middle"), end);
beginning->next = new_middle;
beginning->print_seq();
}
int main(int argc, char *argv[])
{
unsigned int start = 0;
unsigned int total_iter = 0;
if (argc != 3)
usage(argv[0]);
if (argv[1])
start = (unsigned int)atoi(argv[1]);
else
usage(argv[0]);
if (argv[2])
total_iter = (unsigned int)atoi(argv[2]);
else
usage(argv[0]);
// Current sequence.
unsigned int *seq = NULL;
unsigned int seq_size = count_digits(start);
seq = malloc(seq_size * sizeof(unsigned int));
// Convert the starting number in a number sequence
int d = 0;
for(d = seq_size - 1; d >= 0;d--)
{
seq[d] = start % 10;
start /= 10;
}
// New sequence.
unsigned int *new_seq = NULL;
unsigned int new_seq_size = 0;
unsigned int i = 0;
for (i = 0;i<total_iter;i++)
{
update_seq(seq, seq_size, &new_seq, &new_seq_size);
if (i == total_iter - 1)
print_seq(new_seq, new_seq_size);
seq_size = new_seq_size;
new_seq_size = 0;
swap_ptr(&seq, &new_seq);
if (new_seq)
free(new_seq);
}
if (seq)
free(seq);
return 0;
}
int main()
{
int seq[N] = { 9, 1, 3, 5, 2, 4, 7, 6, 8, 0 };
merge_sort(seq);
print_seq(seq);
return 0;
}
bool wp_write_ln(void)
{
bool ok;
ok = print_seq(WRITELN);
char_pos = 0;
return ok;
}
static void
print_src_dst(netdissect_options *ndo, const struct pfsync_state_peer *src,
const struct pfsync_state_peer *dst, uint8_t proto)
{
if (proto == IPPROTO_TCP) {
if (src->state <= TCPS_TIME_WAIT &&
dst->state <= TCPS_TIME_WAIT)
ND_PRINT((ndo, " %s:%s", tcpstates[src->state],
tcpstates[dst->state]));
else if (src->state == PF_TCPS_PROXY_SRC ||
dst->state == PF_TCPS_PROXY_SRC)
ND_PRINT((ndo, " PROXY:SRC"));
else if (src->state == PF_TCPS_PROXY_DST ||
dst->state == PF_TCPS_PROXY_DST)
ND_PRINT((ndo, " PROXY:DST"));
else
ND_PRINT((ndo, " <BAD STATE LEVELS %u:%u>",
src->state, dst->state));
if (vflag > 1) {
ND_PRINT((ndo, "\n\t"));
print_seq(ndo, src);
if (src->wscale && dst->wscale)
ND_PRINT((ndo, " wscale %u",
src->wscale & PF_WSCALE_MASK));
ND_PRINT((ndo, " "));
print_seq(ndo, dst);
if (src->wscale && dst->wscale)
ND_PRINT((ndo, " wscale %u",
dst->wscale & PF_WSCALE_MASK));
}
} else if (proto == IPPROTO_UDP && src->state < PFUDPS_NSTATES &&
dst->state < PFUDPS_NSTATES) {
const char *states[] = PFUDPS_NAMES;
ND_PRINT((ndo, " %s:%s", states[src->state], states[dst->state]));
} else if (proto != IPPROTO_ICMP && src->state < PFOTHERS_NSTATES &&
dst->state < PFOTHERS_NSTATES) {
/* XXX ICMP doesn't really have state levels */
const char *states[] = PFOTHERS_NAMES;
ND_PRINT((ndo, " %s:%s", states[src->state], states[dst->state]));
} else {
ND_PRINT((ndo, " %u:%u", src->state, dst->state));
}
}
static void test_split() {
Seq s;
size_t nb = (size_t) pasl::util::cmdline::parse_or_default_int64("nb", 32);
for (size_t i = 0; i <= nb; i++) {
printf("======= Splitting at %lu ======\n", i);
Seq t;
Seq u;
//Seq::debug_alloc();
push(t, nb, 0);
print_seq(t);
//Seq::debug_alloc();
t.split(i, u);
int sz = t.size();
//Seq::debug_alloc();
print_seq(t);
print_seq(u);
assert(sz == i);
}
}
void print_seq(const char input[], const unsigned int start, const unsigned int end, const unsigned int optimal_k[][MAX_INPUT_LEN]) {
if (start > end) return;
if (start == end) {
if (input[start - 1] == LPAREN || input[start - 1] == RPAREN) {
putc(LPAREN, stdout);
putc(RPAREN, stdout);
}else {
putc(LBRACKET, stdout);
putc(RBRACKET, stdout);
}
}else if (optimal_k[start - 1][end - 1] == UINT_MAX) {
putc(input[start - 1], stdout);
print_seq(input, start + 1, end - 1, optimal_k);
putc(input[end - 1], stdout);
}else {
print_seq(input, start, optimal_k[start - 1][end - 1], optimal_k);
print_seq(input, optimal_k[start - 1][end - 1] + 1, end, optimal_k);
}
}
int main(int argc, char *argv[]) {
char input[MAX_INPUT_LEN + 1];
unsigned int length, i, j, mem[MAX_INPUT_LEN][MAX_INPUT_LEN], optimal_k[MAX_INPUT_LEN][MAX_INPUT_LEN];
scanf("%s", input);
length = strlen(input);
for (i = 0; i < length; ++i) for (mem[i][i] = 1, j = i + 1; j < length; ++j) mem[i][j] = UINT_MAX;
compute_min_num_ins(input, 1, length, mem, optimal_k);
print_seq(input, 1, length, (const unsigned int(*)[MAX_INPUT_LEN])optimal_k);
putc('\n', stdout);
return 0;
}
bool wp_send_init(bool use_nlq)
{
bool ok;
if (use_nlq)
nlq_set = 2;
else
nlq_set = 0;
ok = print_seq(PRINTERINIT); /* allgemeiner Init */
if (ok)
{
print_seq(HORZINIT); /* Horizontale Initialisierung */
print_seq(VERTINIT); /* Vertikale Initialisierung */
print(BOLD, FALSE); /* Fettschrift aus. */
print(ITALIC, FALSE); /* Kursivschrift aus. */
print(LIGHT, FALSE); /* Light aus. */
print(SUPERSCRIPT, FALSE); /* Superscript aus. */
print(SUBSCRIPT, FALSE); /* Subscript aus. */
print(_UNDERLINE, FALSE); /* Unterstreichung aus. */
akt_mode = -1;
print_seq(_1STTYPE); /* PICA (10 CPI) */
akt_color = -1;
print_seq(_1STCOLOR); /* Color-Einstellung: Black. */
proportional = FALSE;
print_seq(PROP + 1); /* proportional-Schrift aus. */
}
return ok;
}
int main(int argc, char *argv[])
{
int c;
int char_length = 32;
int (*char_maker)(int) = numbersCharsAndSymbols;
int use_randlib = 0;
int mac_address = 0;
while ((c = getopt(argc, argv, "ravhn:m")) != -1) {
switch (c) {
case 'a':
char_maker = numbersAndChars;
break;
case 'v':
#ifdef DEVRANDOM
fprintf(stderr, "%s using %s\n", PACKAGE_STRING, DEVRANDOM);
#else
fprintf(stderr, "%s\n", PACKAGE_STRING);
#endif
exit(0);
case 'h':
usage();
exit(0);
case 'r':
use_randlib = 1;
break;
case 'm':
mac_address = 1;
break;
case 'n':
char_length = atoi(optarg);
if (char_length < 1) {
fprintf(stderr, "Must produce at least one character\n");
exit(1);
}
break;
default:
fprintf(stderr, "%s\nUnknown option: %c\n", PACKAGE_STRING, c);
usage();
exit(1);
}
}
if (mac_address)
print_mac_address();
else if (use_randlib)
print_seq_rand_lib(char_length, char_maker);
else
print_seq(char_length, char_maker);
return 0;
}
bool wp_set_mode(int mode)
{
bool ok = TRUE;
if ((mode >= PICA) && (mode <= EXPANDED))
{
if (mode != akt_mode)
{
ok = print_seq(2 * mode + _1STTYPE + (nlq_set / 2));
akt_mode = mode;
}
}
return ok;
}
bool wp_send_exit(void)
{
return print_seq(PRINTERINIT);
}
static void
format_pairs(FILE *f,
const p3_global_settings *pa,
const seq_args *sa,
const p3retval *retval,
const pair_array_t *best_pairs,
const char *pr_release,
const pr_append_str *combined_retval_err,
int explain_flag)
{
char *warning;
int print_lib_sim = lib_sim_specified(pa);
primer_rec *h = NULL;
PR_ASSERT(NULL != f);
PR_ASSERT(NULL != pa);
PR_ASSERT(NULL != sa);
/* If there are errors, print them and return */
if (!pr_is_empty(combined_retval_err)) {
format_error(f, sa->sequence_name,
pr_append_str_chars(combined_retval_err));
return;
}
/* Print the sequence name if it is provided */
if (NULL != sa->sequence_name)
fprintf(f, "PRIMER PICKING RESULTS FOR %s\n\n", sa->sequence_name);
/* Print if a mispriming libraby was used and which one */
if (pa->p_args.repeat_lib != NULL)
fprintf(f, "Using mispriming library %s\n",
pa->p_args.repeat_lib->repeat_file);
else
fprintf(f, "No mispriming library specified\n");
/* Print if a mispriming libraby for the internal oligo
* was used and which one */
if ( pa->pick_internal_oligo == 1 ) {
if (pa->o_args.repeat_lib != NULL)
fprintf(f, "Using internal oligo mishyb library %s\n",
pa->o_args.repeat_lib->repeat_file);
else
fprintf(f, "No internal oligo mishyb library specified\n");
}
/* Does the sequence start at position 0 or 1 ? */
fprintf(f, "Using %d-based sequence positions\n",
pa->first_base_index);
/* Complain if no primers are in the array */
if (best_pairs->num_pairs == 0) fprintf(f, "NO PRIMERS FOUND\n\n");
/* Print out the warings */
if ((warning = p3_get_rv_and_gs_warnings(retval, pa)) != NULL) {
fprintf(f, "WARNING: %s\n\n", warning);
free(warning);
}
/* Print the results for the best pair */
print_summary(f, pa, sa, best_pairs, 0);
fprintf(f, "\n");
/* Print nicely out the sequence with the best pair */
if (print_seq(f, pa, sa, retval, h, best_pairs, 0)) exit(-2); /* ENOMEM */
/* Print out the alternative pairs */
if (best_pairs->num_pairs > 1 ) print_rest(f, pa, sa, best_pairs);
/* Print the primer picking statistics */
if (explain_flag)
print_explain(f, pa, sa, retval, print_lib_sim, pr_release);
/* Flush the buffers and return */
fprintf(f, "\n\n");
if (fflush(f) == EOF) {
perror("fflush(f) failed");
exit(-1);
}
}
static int dump_me(struct findall_data *data, void *rock)
{
int r;
char boundary[128];
struct imapurl url;
char imapurl[MAX_MAILBOX_PATH+1];
struct incremental_record *irec = (struct incremental_record *) rock;
struct searchargs searchargs;
struct index_state *state;
unsigned *uids = NULL;
unsigned *uidseq = NULL;
int i, n, numuids;
unsigned msgno;
/* don't want partial matches */
if (!data || !data->mbname) return 0;
const char *name = mbname_intname(data->mbname);
r = index_open(name, NULL, &state);
if (r) {
if (verbose) {
printf("error opening %s: %s\n", name, error_message(r));
}
return 0;
}
generate_boundary(boundary, sizeof(boundary));
printf("Content-Type: multipart/related; boundary=\"%s\"\n\n", boundary);
printf("--%s\n", boundary);
printf("Content-Type: text/xml\n");
printf("IMAP-Dump-Version: 0\n");
printf("\n");
printf("<imapdump uniqueid=\"%s\">\n", state->mailbox->uniqueid);
memset(&url, 0, sizeof(struct imapurl));
url.server = config_servername;
url.mailbox = name;
imapurl_toURL(imapurl, &url);
printf(" <mailbox-url>%s</mailbox-url>\n", imapurl);
printf(" <incremental-uid>%d</incremental-uid>\n", irec->incruid);
printf(" <nextuid>%u</nextuid>\n", state->mailbox->i.last_uid + 1);
printf("\n");
memset(&searchargs, 0, sizeof(struct searchargs));
searchargs.root = search_expr_new(NULL, SEOP_TRUE);
numuids = index_getuidsequence(state, &searchargs, &uids);
search_expr_free(searchargs.root);
print_seq("uidlist", NULL, uids, numuids);
printf("\n");
printf(" <flags>\n");
searchargs.root = systemflag_match(FLAG_ANSWERED);
uidseq = NULL;
n = index_getuidsequence(state, &searchargs, &uidseq);
search_expr_free(searchargs.root);
print_seq("flag", "name=\"\\Answered\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.root = systemflag_match(FLAG_DELETED);
uidseq = NULL;
n = index_getuidsequence(state, &searchargs, &uidseq);
search_expr_free(searchargs.root);
print_seq("flag", "name=\"\\Deleted\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.root = systemflag_match(FLAG_DRAFT);
uidseq = NULL;
n = index_getuidsequence(state, &searchargs, &uidseq);
search_expr_free(searchargs.root);
print_seq("flag", "name=\"\\Draft\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.root = systemflag_match(FLAG_FLAGGED);
uidseq = NULL;
n = index_getuidsequence(state, &searchargs, &uidseq);
search_expr_free(searchargs.root);
print_seq("flag", "name=\"\\Flagged\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
printf(" </flags>\n");
printf("</imapdump>\n");
i = 0;
while (i < numuids && uids[i] < irec->incruid) {
/* already dumped this message */
/* xxx could do binary search to get to the first
undumped uid */
i++;
}
for (msgno = 1; msgno <= state->exists; msgno++) {
struct buf buf = BUF_INITIALIZER;
struct index_map *im = &state->map[msgno-1];
struct index_record record;
while (im->uid > uids[i] && i < numuids)
i++;
if (i >= numuids)
break;
if (im->uid < uids[i])
continue;
/* got a match */
i++;
memset(&record, 0, sizeof(struct index_record));
record.recno = im->recno;
record.uid = im->uid;
if (mailbox_reload_index_record(state->mailbox, &record))
continue;
printf("\n--%s\n", boundary);
printf("Content-Type: message/rfc822\n");
printf("Content-ID: %d\n", uids[i]);
printf("\n");
r = mailbox_map_record(state->mailbox, &record, &buf);
if (r) {
if (verbose) {
printf("error mapping message %u: %s\n", record.uid,
error_message(r));
}
break;
}
fwrite(buf.s, 1, buf.len, stdout);
buf_free(&buf);
}
printf("\n--%s--\n", boundary);
free(uids);
index_close(&state);
return 0;
}
void
print_state(struct pfsync_state *s, int opts)
{
struct pfsync_state_peer *src, *dst;
struct pfsync_state_key *sk, *nk;
int min, sec, sidx, didx;
if (s->direction == PF_OUT) {
src = &s->src;
dst = &s->dst;
sk = &s->key[PF_SK_STACK];
nk = &s->key[PF_SK_WIRE];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[0] = nk->port[0];
} else {
src = &s->dst;
dst = &s->src;
sk = &s->key[PF_SK_WIRE];
nk = &s->key[PF_SK_STACK];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[1] = nk->port[1];
}
printf("%s ", s->ifname);
printf("%s ", ipproto_string(s->proto));
if (nk->af != sk->af)
sidx = 1, didx = 0;
else
sidx = 0, didx = 1;
print_host(&nk->addr[didx], nk->port[didx], nk->af, nk->rdomain, NULL, opts);
if (nk->af != sk->af || PF_ANEQ(&nk->addr[1], &sk->addr[1], nk->af) ||
nk->port[1] != sk->port[1]) {
printf(" (");
print_host(&sk->addr[1], sk->port[1], sk->af, sk->rdomain,
NULL, opts);
printf(")");
}
if (s->direction == PF_OUT)
printf(" -> ");
else
printf(" <- ");
print_host(&nk->addr[sidx], nk->port[sidx], nk->af, nk->rdomain, NULL,
opts);
if (nk->af != sk->af || PF_ANEQ(&nk->addr[0], &sk->addr[0], nk->af) ||
nk->port[0] != sk->port[0]) {
printf(" (");
print_host(&sk->addr[0], sk->port[0], sk->af, sk->rdomain, NULL,
opts);
printf(")");
}
printf(" ");
if (s->proto == IPPROTO_TCP) {
if (src->state <= TCPS_TIME_WAIT &&
dst->state <= TCPS_TIME_WAIT)
printf("\n %s:%s", tcpstates[src->state],
tcpstates[dst->state]);
else if (src->state == PF_TCPS_PROXY_SRC ||
dst->state == PF_TCPS_PROXY_SRC)
printf("\n PROXY:SRC");
else if (src->state == PF_TCPS_PROXY_DST ||
dst->state == PF_TCPS_PROXY_DST)
printf("\n PROXY:DST");
else
printf("\n <BAD STATE LEVELS %u:%u>",
src->state, dst->state);
if (opts & PF_OPT_VERBOSE) {
printf("\n ");
print_seq(src);
if (src->wscale && dst->wscale)
printf(" wscale %u",
src->wscale & PF_WSCALE_MASK);
printf(" ");
print_seq(dst);
if (src->wscale && dst->wscale)
printf(" wscale %u",
dst->wscale & PF_WSCALE_MASK);
}
} else if (s->proto == IPPROTO_UDP && src->state < PFUDPS_NSTATES &&
dst->state < PFUDPS_NSTATES) {
const char *states[] = PFUDPS_NAMES;
printf(" %s:%s", states[src->state], states[dst->state]);
} else if (s->proto != IPPROTO_ICMP && src->state < PFOTHERS_NSTATES &&
dst->state < PFOTHERS_NSTATES) {
/* XXX ICMP doesn't really have state levels */
const char *states[] = PFOTHERS_NAMES;
printf(" %s:%s", states[src->state], states[dst->state]);
} else {
printf(" %u:%u", src->state, dst->state);
}
if (opts & PF_OPT_VERBOSE) {
u_int64_t packets[2];
u_int64_t bytes[2];
u_int32_t creation = ntohl(s->creation);
u_int32_t expire = ntohl(s->expire);
sec = creation % 60;
creation /= 60;
min = creation % 60;
creation /= 60;
printf("\n age %.2u:%.2u:%.2u", creation, min, sec);
sec = expire % 60;
expire /= 60;
min = expire % 60;
expire /= 60;
printf(", expires in %.2u:%.2u:%.2u", expire, min, sec);
bcopy(s->packets[0], &packets[0], sizeof(u_int64_t));
bcopy(s->packets[1], &packets[1], sizeof(u_int64_t));
bcopy(s->bytes[0], &bytes[0], sizeof(u_int64_t));
bcopy(s->bytes[1], &bytes[1], sizeof(u_int64_t));
printf(", %llu:%llu pkts, %llu:%llu bytes",
betoh64(packets[0]),
betoh64(packets[1]),
betoh64(bytes[0]),
betoh64(bytes[1]));
if (s->anchor != -1)
printf(", anchor %u", ntohl(s->anchor));
if (s->rule != -1)
printf(", rule %u", ntohl(s->rule));
}
if (opts & PF_OPT_VERBOSE2) {
u_int64_t id;
bcopy(&s->id, &id, sizeof(u_int64_t));
printf("\n id: %016llx creatorid: %08x",
betoh64(id), ntohl(s->creatorid));
}
}
static void
format_oligos(FILE *f,
const p3_global_settings *pa,
const seq_args *sa,
const p3retval *retval,
const char* pr_release,
const pr_append_str *combined_retval_err,
int explain_flag)
{
char *warning;
int print_lib_sim = lib_sim_specified(pa);
int i;
int print_primers = 0;
primer_rec *h = NULL;
pair_array_t *best_pairs;
primer_rec *p;
int rest_count = 0;
PR_ASSERT(NULL != f);
PR_ASSERT(NULL != pa);
PR_ASSERT(NULL != sa);
best_pairs = NULL;
if (!pr_is_empty(combined_retval_err)) {
format_error(f, sa->sequence_name, pr_append_str_chars(combined_retval_err));
return;
}
if (NULL != sa->sequence_name)
fprintf(f, "PRIMER PICKING RESULTS FOR %s\n\n", sa->sequence_name);
if (pa->pick_left_primer || pa->pick_right_primer) {
if (pa->p_args.repeat_lib != NULL)
fprintf(f, "Using mispriming library %s\n",
pa->p_args.repeat_lib->repeat_file);
else
fprintf(f, "No mispriming library specified\n");
}
if (pa->pick_internal_oligo) {
if (pa->o_args.repeat_lib != NULL)
fprintf(f, "Using internal probe mishyb library %s\n", pa->o_args.repeat_lib->repeat_file);
else
fprintf(f, "No internal probe mishyb library specified\n");
}
fprintf(f, "Using %d-based sequence positions\n", pa->first_base_index);
if (pa->pick_left_primer) {
if (retval->fwd.num_elem == 0) {
fprintf(f, "NO LEFT PRIMER FOUND\n\n");
} else {
print_primers = 1;
}
}
if (pa->pick_internal_oligo) {
if (retval->intl.num_elem == 0) {
fprintf(f, "NO INTERNAL PROBE FOUND\n\n");
} else {
print_primers = 1;
}
}
if (pa->pick_right_primer) {
if (retval->rev.num_elem == 0) {
fprintf(f, "NO RIGHT PRIMER FOUND\n\n");
} else {
print_primers = 1;
}
}
if ((warning = p3_get_rv_and_gs_warnings(retval, pa)) != NULL) {
fprintf(f, "\nWARNING: %s\n", warning);
free(warning);
}
if ((pa->primer_task != pick_primer_list ) && (pa->primer_task != pick_sequencing_primers)) {
if (print_primers == 1) {
print_oligo_header(f, "OLIGO", print_lib_sim, pa->thermodynamic_alignment, sa->tar2.genotyping);
}
/* Print out the first line with the best primers */
if ((pa->pick_left_primer) && (&retval->fwd != NULL ) && (retval->fwd.num_elem > 0)) {
if(pa->modify_left_primer==1) {
print_oligo_Z(f, TITLE_MOD_LEFT, sa, retval->fwd.oligo, OT_LEFT, pa, pa->p_args.repeat_lib, print_lib_sim);
} else {
print_oligo_Z(f, TITLE_LEFT, sa, retval->fwd.oligo, OT_LEFT, pa, pa->p_args.repeat_lib, print_lib_sim);
}
h = retval->fwd.oligo;
rest_count = 1;
}
if ((pa->pick_internal_oligo) && (&retval->intl != NULL ) && (retval->intl.num_elem > 0)) {
if(pa->modify_internal_oligo==1) {
if((retval->intl.oligo)->oligo_dir==0) {
print_oligo_Z(f, TITLE_MOD_INTL_FW, sa, retval->intl.oligo, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
} else if((retval->intl.oligo)->oligo_dir==1) {
print_oligo_Z(f, TITLE_MOD_INTL_RV, sa, retval->intl.oligo, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
}
} else {
if((retval->intl.oligo)->oligo_dir==0) {
print_oligo_Z(f, TITLE_INTL_FW, sa, retval->intl.oligo, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
} else if((retval->intl.oligo)->oligo_dir==1) {
print_oligo_Z(f, TITLE_INTL_RV, sa, retval->intl.oligo, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
}
}
h = retval->intl.oligo;
rest_count = 1;
}
if ((pa->pick_right_primer) && (&retval->rev != NULL ) && (retval->rev.num_elem > 0)) {
if(pa->modify_right_primer==1) {
print_oligo_Z(f, TITLE_MOD_RIGHT, sa, retval->rev.oligo, OT_RIGHT, pa, pa->p_args.repeat_lib, print_lib_sim);
} else {
print_oligo_Z(f, TITLE_RIGHT, sa, retval->rev.oligo, OT_RIGHT, pa, pa->p_args.repeat_lib, print_lib_sim);
}
h = retval->rev.oligo;
rest_count = 1;
}
}
if(print_primers == 1) {
fprintf(f, "SEQUENCE SIZE: %ld\n", (long int) strlen(sa->sequence));
fprintf(f, "INCLUDED REGION SIZE: %d\n\n", sa->incl_l);
if(sa->tar2.genotyping==0) {
print_pair_array(f, "TARGETS", sa->tar2.count, sa->tar2.pairs, pa, sa);
} else if(sa->tar2.genotyping==1) {
fprintf(f,"TARGET VARIANT * (position,size):");
if(sa->tar2.char_count==sa->tar2.VAR_sequence_number) {
fprintf(f," %d,%d",sa->tar2.VAR_start[0],sa->tar2.char_num[sa->tar2.VAR_sequence_number]-1);
} else {
fprintf(f," %d,%d",sa->tar2.VAR_start[0],sa->tar2.char_num[sa->tar2.VAR_sequence_number]);
}
fprintf(f,"\n\n");
}
print_pair_array(f, "EXCLUDED REGIONS", sa->excl2.count, sa->excl2.pairs, pa, sa);
print_pair_array(f, "INTERNAL PROBE EXCLUDED REGIONS", sa->excl_internal2.count, sa->excl_internal2.pairs, pa, sa);
print_2_pair_array(f, "PAIR_OK_REGIONS", sa->ok_regions.count, sa->ok_regions.left_pairs, sa->ok_regions.right_pairs, pa, sa);
}
if (pa->primer_task != pick_primer_list ) {
if(pa->pick_internal_oligo==1) {
if(print_seq(f,pa,sa,retval,retval->intl.oligo,best_pairs,0)) exit(-2);
}
else if(pa->pick_left_primer==1) {
if(print_seq(f,pa,sa,retval,retval->fwd.oligo,best_pairs,0)) exit(-2);
}
else if(pa->pick_right_primer==1) {
if(print_seq(f,pa,sa,retval,retval->rev.oligo,best_pairs,0)) exit(-2);
}
else if (print_seq(f, pa, sa, retval, h, best_pairs, 0)) exit(-2); /* ENOMEM */
}
fprintf(f, "\n");
/* Print out the other primers */
if ((pa->pick_left_primer) && (&retval->fwd != NULL ) && (retval->fwd.num_elem > rest_count)) {
int n = retval->fwd.num_elem;
h = retval->fwd.oligo;
if (rest_count == 1) {
fprintf(f, "ADDITIONAL OLIGOS\n");
}
fprintf(f, " ");
print_oligo_header(f, "", print_lib_sim, pa->thermodynamic_alignment, sa->tar2.genotyping);
for (i = rest_count; i < pa->num_return; i++) {
if(i > n-1) break;
p = h + i;
fprintf(f, "%2d ", i + 1 - rest_count);
if(pa->modify_left_primer==1) {
print_oligo_Z(f, TITLE_MOD_LEFT, sa, p, OT_LEFT, pa, pa->p_args.repeat_lib, print_lib_sim);
} else {
print_oligo_Z(f, TITLE_LEFT, sa, p, OT_LEFT, pa, pa->p_args.repeat_lib, print_lib_sim);
}
}
if (rest_count == 0) {
fprintf(f, "\n ");
}
}
if ((pa->pick_internal_oligo) && (&retval->intl != NULL ) && (retval->intl.num_elem > rest_count)) {
int n = retval->intl.num_elem;
h = retval->intl.oligo;
if (rest_count == 1) {
fprintf(f, "ADDITIONAL OLIGOS\n");
}
fprintf(f, " ");
print_oligo_header(f, "", print_lib_sim, pa->thermodynamic_alignment, sa->tar2.genotyping);
for (i = rest_count; i < pa->num_return; i++) {
if(i > n-1) break;
p = h + i;
fprintf(f, "%2d ", i + 1 - rest_count);
if(pa->modify_internal_oligo==1) {
if(p->oligo_dir==0) {
print_oligo_Z(f, TITLE_MOD_INTL_FW, sa, p, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
} else if(p->oligo_dir==1) {
print_oligo_Z(f, TITLE_MOD_INTL_RV, sa, p, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
}
} else {
if(p->oligo_dir==0) {
print_oligo_Z(f, TITLE_INTL_FW, sa, p, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
} else if(p->oligo_dir==1) {
print_oligo_Z(f, TITLE_INTL_RV, sa, p, OT_INTL, pa, pa->p_args.repeat_lib, print_lib_sim);
}
}
}
if (rest_count == 0) {
fprintf(f, "\n ");
}
}
if ((pa->pick_right_primer) && (&retval->rev != NULL ) && (retval->rev.num_elem > rest_count)) {
int n = retval->rev.num_elem;
h = retval->rev.oligo;
if (rest_count == 1) {
fprintf(f, "ADDITIONAL OLIGOS\n");
}
fprintf(f, " ");
print_oligo_header(f, "", print_lib_sim, pa->thermodynamic_alignment, sa->tar2.genotyping);
for (i = rest_count; i < pa->num_return; i++) {
if(i > n-1) break;
p = h + i;
fprintf(f, "%2d ", i + 1 - rest_count);
if(pa->modify_right_primer==1) {
print_oligo_Z(f, TITLE_MOD_RIGHT, sa, p, OT_RIGHT, pa, pa->p_args.repeat_lib, print_lib_sim);
} else {
print_oligo_Z(f, TITLE_RIGHT, sa, p, OT_RIGHT, pa, pa->p_args.repeat_lib, print_lib_sim);
}
}
}
if (explain_flag)
print_explain(f, pa, sa, retval, print_lib_sim, pr_release);
fprintf(f, "\n\n");
if (fflush(f) == EOF) {
perror("fflush(f) failed");
exit(-1);
}
}
int main(int argc, char** argv) {
FILE *fin, *fout;
fin = fopen("contact.in", "r");
fout = fopen("contact.out", "w");
v_t count[0x2001];
int a, b, n;
int current = 0;
int i;
int v;
int n_bits;
int m;
int j;
char c;
for (i = 0; i < 0x2000; i++) {
count[i].v = i;
count[i].c = 0;
}
fscanf(fin, "%d %d %d", &a, &b, &n);
v = 0;
n_bits = 0;
while ((c = fgetc(fin)) != EOF) {
if (c != '\n') {
n_bits++;
c -= '0';
v = (v << 1) | c;
m = n_bits>=b?b:n_bits;
for (i = a; i <= m; i++) {
count[v&mask[i]|prefix[i]].c++;
}
}
}
qsort(count, 1 << (b+1), sizeof(v_t), cmp_v_t);
m = 1 << (b+1);
i = 0;
v = 0;
while (v++ < n) {
if (count[i].c == 0) {
break;
}
fprintf(fout, "%d\n", count[i].c);
current = count[i].c;
print_seq(fout, count[i].v);
j = 1;
i++;
while (count[i].c == current) {
fprintf(fout, j % 6 == 0 ? "\n" : " ");
print_seq(fout, count[i].v);
i++;
j++;
}
fprintf(fout, "\n");
}
return 0;
}
void
print_state(struct pfsync_state *s, int opts)
{
struct pfsync_state_peer *src, *dst;
struct pfsync_state_key *sk, *nk;
struct protoent *p;
int min, sec;
if (s->direction == PF_OUT) {
src = &s->src;
dst = &s->dst;
sk = &s->key[PF_SK_STACK];
nk = &s->key[PF_SK_WIRE];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[0] = nk->port[0];
} else {
src = &s->dst;
dst = &s->src;
sk = &s->key[PF_SK_WIRE];
nk = &s->key[PF_SK_STACK];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[1] = nk->port[1];
}
printf("%s ", s->ifname);
if ((p = getprotobynumber(s->proto)) != NULL)
printf("%s ", p->p_name);
else
printf("%u ", s->proto);
print_host(&nk->addr[1], nk->port[1], s->af, opts);
if (PF_ANEQ(&nk->addr[1], &sk->addr[1], s->af) ||
nk->port[1] != sk->port[1]) {
printf(" (");
print_host(&sk->addr[1], sk->port[1], s->af, opts);
printf(")");
}
if (s->direction == PF_OUT)
printf(" -> ");
else
printf(" <- ");
print_host(&nk->addr[0], nk->port[0], s->af, opts);
if (PF_ANEQ(&nk->addr[0], &sk->addr[0], s->af) ||
nk->port[0] != sk->port[0]) {
printf(" (");
print_host(&sk->addr[0], sk->port[0], s->af, opts);
printf(")");
}
printf(" ");
if (s->proto == IPPROTO_TCP) {
if (src->state <= TCPS_TIME_WAIT &&
dst->state <= TCPS_TIME_WAIT)
printf(" %s:%s\n", tcpstates[src->state],
tcpstates[dst->state]);
else if (src->state == PF_TCPS_PROXY_SRC ||
dst->state == PF_TCPS_PROXY_SRC)
printf(" PROXY:SRC\n");
else if (src->state == PF_TCPS_PROXY_DST ||
dst->state == PF_TCPS_PROXY_DST)
printf(" PROXY:DST\n");
else
printf(" <BAD STATE LEVELS %u:%u>\n",
src->state, dst->state);
if (opts & PF_OPT_VERBOSE) {
printf(" ");
print_seq(src);
if (src->wscale && dst->wscale)
printf(" wscale %u",
src->wscale & PF_WSCALE_MASK);
printf(" ");
print_seq(dst);
if (src->wscale && dst->wscale)
printf(" wscale %u",
dst->wscale & PF_WSCALE_MASK);
printf("\n");
}
} else if (s->proto == IPPROTO_UDP && src->state < PFUDPS_NSTATES &&
dst->state < PFUDPS_NSTATES) {
const char *states[] = PFUDPS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
} else if (s->proto != IPPROTO_ICMP && src->state < PFOTHERS_NSTATES &&
dst->state < PFOTHERS_NSTATES) {
/* XXX ICMP doesn't really have state levels */
const char *states[] = PFOTHERS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
} else {
printf(" %u:%u\n", src->state, dst->state);
}
if (opts & PF_OPT_VERBOSE) {
u_int64_t packets[2];
u_int64_t bytes[2];
u_int32_t creation = ntohl(s->creation);
u_int32_t expire = ntohl(s->expire);
printf(" rule %u", ntohl(s->rule));
if (ntohl(s->anchor) != -1)
printf(", anchor %u", ntohl(s->anchor));
printf(", flags:");
if (s->state_flags & PFSTATE_ALLOWOPTS)
printf(" allowopts");
if (s->state_flags & PFSTATE_SLOPPY)
printf(" sloppy");
if (s->state_flags & PFSTATE_STACK_GLOBAL)
printf(" global");
if (s->state_flags & PFSTATE_CREATEINPROG)
printf(" creating");
if (s->state_flags & PFSTATE_HALF_DUPLEX)
printf(" (TRANSLATION COLLISION)");
if (s->sync_flags & PFSYNC_FLAG_SRCNODE)
printf(" source-track");
if (s->sync_flags & PFSYNC_FLAG_NATSRCNODE)
printf(" sticky-address");
switch(s->pickup_mode) {
case PF_PICKUPS_UNSPECIFIED:
break;
case PF_PICKUPS_DISABLED:
printf(" no-pickups");
break;
case PF_PICKUPS_HASHONLY:
printf(" hash-only");
break;
case PF_PICKUPS_ENABLED:
printf(" pickups");
break;
}
printf("\n");
sec = creation % 60;
creation /= 60;
min = creation % 60;
creation /= 60;
printf(" age %.2u:%.2u:%.2u", creation, min, sec);
sec = expire % 60;
expire /= 60;
min = expire % 60;
expire /= 60;
printf(", expires in %.2u:%.2u:%.2u", expire, min, sec);
bcopy(s->packets[0], &packets[0], sizeof(u_int64_t));
bcopy(s->packets[1], &packets[1], sizeof(u_int64_t));
bcopy(s->bytes[0], &bytes[0], sizeof(u_int64_t));
bcopy(s->bytes[1], &bytes[1], sizeof(u_int64_t));
printf(", %" PRIu64 ":%" PRIu64 " pkts, %" PRIu64 ":%"
PRIu64 " bytes\n",
be64toh(packets[0]),
be64toh(packets[1]),
be64toh(bytes[0]),
be64toh(bytes[1]));
}
if (opts & PF_OPT_VERBOSE2) {
u_int64_t id;
bcopy(&s->id, &id, sizeof(u_int64_t));
printf(" id: %016jx creatorid: %08x cpuid: %-3d",
be64toh(id), ntohl(s->creatorid), s->cpuid);
printf("\n");
}
}
struct seq_stats* collect_data(struct seq_stats* seq_stats,struct parameters* param,int (*fp)(struct read_info** ,struct parameters*,FILE* ),int file_num)
{
struct read_info** ri = 0;
int i,j,c;
int test = 1;
int numseq;
int qual_key = 0;
int aln_len = 0;
//char command[1000];
//char tmp[1000];
FILE* file = 0;
FILE* unmapped = 0;
ri = malloc(sizeof(struct read_info*) * param->num_query);
for(i = 0; i < param->num_query;i++){
ri[i] = malloc(sizeof(struct read_info));
ri[i]->seq = 0;
ri[i]->name = 0;
ri[i]->qual = 0;
ri[i]->len = 0;
ri[i]->cigar = 0;
ri[i]->md = 0;
ri[i]->xp = 0;
ri[i]->priors = 0;// malloc(sizeof(unsigned int)* (LIST_STORE_SIZE+1));
ri[i]->strand = malloc(sizeof(unsigned int)* (LIST_STORE_SIZE+1));
ri[i]->hits = malloc(sizeof(unsigned int)* (LIST_STORE_SIZE+1));
ri[i]->identity = malloc(sizeof(float)* (LIST_STORE_SIZE+1));
}
file = io_handler(file, file_num,param);
if(param->print_unmapped){
if (!(unmapped = fopen(param->print_unmapped, "w" ))){
fprintf(stderr,"Cannot open file '%s'\n",param->print_unmapped);
exit(-1);
}
}
while ((numseq = fp(ri, param,file)) != 0){
//fprintf(stderr,"rread: %d\n",numseq);
for(i = 0; i < numseq;i++){
if(ri[i]->len > seq_stats->max_len){
seq_stats->max_len = ri[i]->len;
}
if(ri[i]->len < seq_stats->min_len ){
seq_stats->min_len = ri[i]->len;
}
if(ri[i]->hits[0] == 0){
qual_key = 5;
if(param->print_unmapped){
print_seq(ri[i],unmapped);
}
}else{
if(ri[i]->mapq < 3){
qual_key = 0;
}else if(ri[i]->mapq < 10){
qual_key = 1;
}else if(ri[i]->mapq < 20){
qual_key = 2;
}else if(ri[i]->mapq < 30){
qual_key = 3;
}else{
qual_key = 4;
}
}
if(ri[i]->errors > param->k_errors_allowed && param->k_errors_allowed != -1){
qual_key = 5;
}
if(ri[i]->cigar && ri[i]->md){
if(ri[i]->cigar[0] != '*'){
aln_len = parse_cigar_md(ri[i],seq_stats, qual_key);
seq_stats->md = 1;
}
}
if(ri[i]->strand[0] != 0){
ri[i]->seq = reverse_complement2(ri[i]->seq,ri[i]->len);
if(ri[i]->qual[0] != '*'){
ri[i]->qual = reverse_without_complement(ri[i]->qual, ri[i]->len);
}
if(ri[i]->xp){
ri[i]->xp = reverse_without_complement(ri[i]->xp, ri[i]->len);
}
}
if(ri[i]->qual){
if(ri[i]->qual[0] != '*'){
param->print_qual = 1;
for(j = 0; j < ri[i]->len;j++){
seq_stats->seq_quality[qual_key][j] += (int)(ri[i]->qual[j]);
if((int)(ri[i]->qual[j]) > 80){
param->solexa = 1;
}
//fprintf(stderr,"%d %d %c %d\n",j,qual_key,ri[i]->qual[j] , (int)(ri[i]->qual[j] -33));
}
}
}
if(ri[i]->xp){
param->print_posteriors = 1;
for(j = 0; j < ri[i]->len;j++){
seq_stats->posterior_mappability[qual_key][j] += (int)(ri[i]->xp[j])-33;
}
}
seq_stats->alignments[qual_key]++;
// sequence length
if(ri[i]->len >= MAX_SEQ_LEN){
seq_stats->seq_len[qual_key][MAX_SEQ_LEN-1]++;
}else{
seq_stats->seq_len[qual_key][ri[i]->len]++;
}
// sequence composition
for(j = 0;j < ri[i]->len;j++){
seq_stats->nuc_num[ri[i]->seq[j]]++;
seq_stats->nuc_composition[qual_key][j][ri[i]->seq[j]]++;
}
//kmers
for(j = 0;j <= ri[i]->len - param->kmer_size;j++){
//check for 'N'
test = 1;
for(c = j;c < j + param->kmer_size;c++){
if(ri[i]->seq[c] >= 4){
test = 0;
break;
}
}
// no 'N'? ok proceed
if(test){
test = 0;
for(c = j;c < j + param->kmer_size;c++){
test = test << 2 | ri[i]->seq[c];
}
seq_stats->kmers[qual_key][j][test]++;
}
}
// ten mers.
for(j = 0;j <= ri[i]->len - KMERLEN;j++){
//check for 'N'
test = 1;
for(c = j;c < j + KMERLEN;c++){
if(ri[i]->seq[c] >= 4){
test = 0;
break;
}
}
// no 'N'? ok proceed
if(test){
test = 0;
for(c = j;c < j + KMERLEN;c++){
test = test << 2 | ri[i]->seq[c];
}
seq_stats->ten_mers[qual_key][test]->count++;
//seq_stats->overall_kmers[test]+= 1.0f;
}
}
//errors
if(ri[i]->errors != -1){
seq_stats->percent_identity[qual_key] +=(((double)aln_len - (double)ri[i]->errors) / (double)aln_len * 100.0);// ((float)aln_len - (float)ri[i]->errors) / (float) aln_len * 100.0f;
//if((int) floor((((float)aln_len - (float)ri[i]->errors) / (float)aln_len * 1000.0f) + 0.5f ) > 1000 || (int) floor((((float)aln_len - (float)ri[i]->errors) / (float)aln_len * 1000.0f) + 0.5f ) < 0 ){
// fprintf(stderr,"ERROR: %f %f\n", (float)aln_len, (float)ri[i]->errors);
//}
//fprintf(stderr,"%d %d %d %d\n",qual_key,aln_len,ri[i]->errors,(int) floor((((float)aln_len - (float)ri[i]->errors) / (float)aln_len * 1000.0f) + 0.5 ));
if(ri[i]->errors >= MAXERROR){
seq_stats->errors[qual_key][MAXERROR-1]++;
}else{
seq_stats->errors[qual_key][ri[i]->errors]++;
}
}
}
}
if(param->print_unmapped){
fclose(unmapped);
}
for(i = 0; i < param->num_query;i++){
free(ri[i]->strand);
free(ri[i]->hits);
free(ri[i]->identity);
if(ri[i]->cigar){
free(ri[i]->cigar);
}
if(ri[i]->md){
free(ri[i]->md);
}
free(ri[i]);
}
free(ri);
//fprintf(stderr,"%p\n",file);
if(param->sam == 2 || param->sam == 1){
pclose(file);
}else{
//if(file_num != -1){
fclose(file);
//}
}
return seq_stats;
}
static bool print(int entry, bool set) /* Ausgabe der angew�hlten Steuersequenz */
{
if (!set)
entry++;
return print_seq(entry + nlq_set);
}
/**********************************************************************
* Function util_menu()
*
* Parameter:
*
*
* This function is the backbone of the interface. All file input/ouput
* happens here. This is also where the user can key in their own string
* if desired. Here the user can view, delete and list the available
* sequences.
*
*
**********************************************************************/
void util_menu()
{
int num_seqs, num_lines;
while (1) {
num_seqs = get_num_sequences();
num_lines = 14;
printf("\n** String Utilites Menu **\n\n");
printf("1) Read formatted file\n");
printf("2) Read unformatted file\n");
printf("3) Create new sequence\n");
if (num_seqs == 0)
printf("4) List sequences (currently available: None)\n");
else
printf("4) List sequences (currently available: 1 - %d)\n", num_seqs);
printf("5) Print sequence\n");
printf("6) Save sequences\n");
printf("7) Delete sequences\n");
printf("8) Set output options\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
fread_formatted();
break;
case '2':
fread_unformatted();
break;
case '3':
type_in_seq();
break;
case '4':
list_sequences(num_lines);
break;
case '5':
print_seq(num_lines);
break;
case '6':
fwrite_formatted();
break;
case '7':
delete_seq();
break;
case '8':
set_display_options();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
static int dump_me(char *name, int matchlen __attribute__((unused)),
int maycreate __attribute__((unused)), void *rock)
{
int r;
char boundary[128];
struct imapurl url;
char imapurl[MAX_MAILBOX_PATH+1];
struct incremental_record *irec = (struct incremental_record *) rock;
struct searchargs searchargs;
struct index_state *state;
unsigned *uids;
unsigned *uidseq;
int i, n, numuids;
r = index_open(name, NULL, &state);
if (r) {
if (verbose) {
printf("error opening %s: %s\n", name, error_message(r));
}
return 0;
}
generate_boundary(boundary, sizeof(boundary));
printf("Content-Type: multipart/related; boundary=\"%s\"\n\n", boundary);
printf("--%s\n", boundary);
printf("Content-Type: text/xml\n");
printf("IMAP-Dump-Version: 0\n");
printf("\n");
printf("<imapdump uniqueid=\"%s\">\n", state->mailbox->uniqueid);
memset(&url, 0, sizeof(struct imapurl));
url.server = config_servername;
url.mailbox = name;
imapurl_toURL(imapurl, &url);
printf(" <mailbox-url>%s</mailbox-url>\n", imapurl);
printf(" <incremental-uid>%d</incremental-uid>\n", irec->incruid);
printf(" <nextuid>%u</nextuid>\n", state->mailbox->i.last_uid + 1);
printf("\n");
memset(&searchargs, 0, sizeof(struct searchargs));
numuids = index_getuidsequence(state, &searchargs, &uids);
print_seq("uidlist", NULL, uids, numuids);
printf("\n");
printf(" <flags>\n");
searchargs.system_flags_set = FLAG_ANSWERED;
n = index_getuidsequence(state, &searchargs, &uidseq);
print_seq("flag", "name=\"\\Answered\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.system_flags_set = FLAG_DELETED;
n = index_getuidsequence(state, &searchargs, &uidseq);
print_seq("flag", "name=\"\\Deleted\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.system_flags_set = FLAG_DRAFT;
n = index_getuidsequence(state, &searchargs, &uidseq);
print_seq("flag", "name=\"\\Draft\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
searchargs.system_flags_set = FLAG_FLAGGED;
n = index_getuidsequence(state, &searchargs, &uidseq);
print_seq("flag", "name=\"\\Flagged\" user=\"*\"", uidseq, n);
if (uidseq) free(uidseq);
printf(" </flags>\n");
printf("</imapdump>\n");
for (i = 0; i < numuids; i++) {
const char *base;
size_t len;
if (uids[i] < irec->incruid) {
/* already dumped this message */
/* xxx could do binary search to get to the first
undumped uid */
continue;
}
printf("\n--%s\n", boundary);
printf("Content-Type: message/rfc822\n");
printf("Content-ID: %d\n", uids[i]);
printf("\n");
r = mailbox_map_message(state->mailbox, uids[i], &base, &len);
if (r) {
if (verbose) {
printf("error mapping message %d: %s\n", uids[i],
error_message(r));
}
break;
}
fwrite(base, 1, len, stdout);
mailbox_unmap_message(state->mailbox, uids[i], &base, &len);
}
printf("\n--%s--\n", boundary);
index_close(&state);
return 0;
}
bool wp_formfeed(void)
{
return print_seq(FORMFEED);
}
void
print_state(struct pfsync_state *s, int opts)
{
struct pfsync_state_peer *src, *dst;
struct pfsync_state_key *sk, *nk;
struct protoent *p;
int min, sec;
if (s->direction == PF_OUT) {
src = &s->src;
dst = &s->dst;
sk = &s->key[PF_SK_STACK];
nk = &s->key[PF_SK_WIRE];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[0] = nk->port[0];
} else {
src = &s->dst;
dst = &s->src;
sk = &s->key[PF_SK_WIRE];
nk = &s->key[PF_SK_STACK];
if (s->proto == IPPROTO_ICMP || s->proto == IPPROTO_ICMPV6)
sk->port[1] = nk->port[1];
}
printf("%s ", s->ifname);
if ((p = getprotobynumber(s->proto)) != NULL)
printf("%s ", p->p_name);
else
printf("%u ", s->proto);
print_host(&nk->addr[1], nk->port[1], s->af, opts);
if (PF_ANEQ(&nk->addr[1], &sk->addr[1], s->af) ||
nk->port[1] != sk->port[1]) {
printf(" (");
print_host(&sk->addr[1], sk->port[1], s->af, opts);
printf(")");
}
if (s->direction == PF_OUT)
printf(" -> ");
else
printf(" <- ");
print_host(&nk->addr[0], nk->port[0], s->af, opts);
if (PF_ANEQ(&nk->addr[0], &sk->addr[0], s->af) ||
nk->port[0] != sk->port[0]) {
printf(" (");
print_host(&sk->addr[0], sk->port[0], s->af, opts);
printf(")");
}
printf(" ");
if (s->proto == IPPROTO_TCP) {
if (src->state <= TCPS_TIME_WAIT &&
dst->state <= TCPS_TIME_WAIT)
printf(" %s:%s\n", tcpstates[src->state],
tcpstates[dst->state]);
else if (src->state == PF_TCPS_PROXY_SRC ||
dst->state == PF_TCPS_PROXY_SRC)
printf(" PROXY:SRC\n");
else if (src->state == PF_TCPS_PROXY_DST ||
dst->state == PF_TCPS_PROXY_DST)
printf(" PROXY:DST\n");
else
printf(" <BAD STATE LEVELS %u:%u>\n",
src->state, dst->state);
if (opts & PF_OPT_VERBOSE) {
printf(" ");
print_seq(src);
if (src->wscale && dst->wscale)
printf(" wscale %u",
src->wscale & PF_WSCALE_MASK);
printf(" ");
print_seq(dst);
if (src->wscale && dst->wscale)
printf(" wscale %u",
dst->wscale & PF_WSCALE_MASK);
printf("\n");
}
} else if (s->proto == IPPROTO_UDP && src->state < PFUDPS_NSTATES &&
dst->state < PFUDPS_NSTATES) {
const char *states[] = PFUDPS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
#ifndef INET6
} else if (s->proto != IPPROTO_ICMP && src->state < PFOTHERS_NSTATES &&
dst->state < PFOTHERS_NSTATES) {
#else
} else if (s->proto != IPPROTO_ICMP && s->proto != IPPROTO_ICMPV6 &&
src->state < PFOTHERS_NSTATES && dst->state < PFOTHERS_NSTATES) {
#endif
/* XXX ICMP doesn't really have state levels */
const char *states[] = PFOTHERS_NAMES;
printf(" %s:%s\n", states[src->state], states[dst->state]);
} else {
printf(" %u:%u\n", src->state, dst->state);
}
if (opts & PF_OPT_VERBOSE) {
u_int64_t packets[2];
u_int64_t bytes[2];
u_int32_t creation = ntohl(s->creation);
u_int32_t expire = ntohl(s->expire);
sec = creation % 60;
creation /= 60;
min = creation % 60;
creation /= 60;
printf(" age %.2u:%.2u:%.2u", creation, min, sec);
sec = expire % 60;
expire /= 60;
min = expire % 60;
expire /= 60;
printf(", expires in %.2u:%.2u:%.2u", expire, min, sec);
bcopy(s->packets[0], &packets[0], sizeof(u_int64_t));
bcopy(s->packets[1], &packets[1], sizeof(u_int64_t));
bcopy(s->bytes[0], &bytes[0], sizeof(u_int64_t));
bcopy(s->bytes[1], &bytes[1], sizeof(u_int64_t));
printf(", %ju:%ju pkts, %ju:%ju bytes",
(uintmax_t )be64toh(packets[0]),
(uintmax_t )be64toh(packets[1]),
(uintmax_t )be64toh(bytes[0]),
(uintmax_t )be64toh(bytes[1]));
if (ntohl(s->anchor) != -1)
printf(", anchor %u", ntohl(s->anchor));
if (ntohl(s->rule) != -1)
printf(", rule %u", ntohl(s->rule));
if (s->state_flags & PFSTATE_SLOPPY)
printf(", sloppy");
if (s->sync_flags & PFSYNC_FLAG_SRCNODE)
printf(", source-track");
if (s->sync_flags & PFSYNC_FLAG_NATSRCNODE)
printf(", sticky-address");
printf("\n");
}
if (opts & PF_OPT_VERBOSE2) {
u_int64_t id;
bcopy(&s->id, &id, sizeof(u_int64_t));
printf(" id: %016jx creatorid: %08x",
(uintmax_t )be64toh(id), ntohl(s->creatorid));
printf("\n");
}
}
void
print_state(struct pf_state *s, int opts)
{
struct pf_state_peer *src, *dst;
struct protoent *p;
u_int8_t hrs, min, sec;
if (s->direction == PF_OUT) {
src = &s->src;
dst = &s->dst;
} else {
src = &s->dst;
dst = &s->src;
}
if ((p = getprotobynumber(s->proto)) != NULL)
printf("%s ", p->p_name);
else
printf("%u ", s->proto);
if (PF_ANEQ(&s->lan.addr, &s->gwy.addr, s->af) ||
(s->lan.port != s->gwy.port)) {
print_host(&s->lan, s->af);
if (s->direction == PF_OUT)
printf(" -> ");
else
printf(" <- ");
}
print_host(&s->gwy, s->af);
if (s->direction == PF_OUT)
printf(" -> ");
else
printf(" <- ");
print_host(&s->ext, s->af);
printf(" ");
if (s->proto == IPPROTO_TCP) {
if (src->state <= TCPS_TIME_WAIT &&
dst->state <= TCPS_TIME_WAIT) {
printf(" %s:%s\n", tcpstates[src->state],
tcpstates[dst->state]);
} else {
printf(" <BAD STATE LEVELS>\n");
}
if (opts & PF_OPT_VERBOSE) {
printf(" ");
print_seq(src);
printf(" ");
print_seq(dst);
printf("\n");
}
} else {
printf(" %u:%u\n", src->state, dst->state);
}
if (opts & PF_OPT_VERBOSE) {
sec = s->creation % 60;
s->creation /= 60;
min = s->creation % 60;
s->creation /= 60;
hrs = s->creation;
printf(" age %.2u:%.2u:%.2u", hrs, min, sec);
sec = s->expire % 60;
s->expire /= 60;
min = s->expire % 60;
s->expire /= 60;
hrs = s->expire;
printf(", expires in %.2u:%.2u:%.2u", hrs, min, sec);
printf(", %u pkts, %u bytes\n", s->packets, s->bytes);
}
}
