/* The main function of our program. */ int main() { /* Our variables we store the result in. */ uint8_t post_x; /* Initialize to 0 so we are sure there is no garbage. */ post_x = 0; /* Print out the bits before we call our function. */ printf("\n\nx:\t\t"); print_binary(X_BITS); printf("\np: %d\nn: %d\n\n", P, N); /* Call our invert() function and save the result * in the post_x var. Remember that the second input * var to invert() is the position and the third is * the number of bits. See invert() for more details. */ post_x = invert(X_BITS, P, N); /* Print out the bits after we call our function. */ printf("result:\t\t"); print_binary(post_x); printf("\n\n"); /* Be a good main function and return 0 because all went fine. */ return 0; }
int compute_HD(int n1,int i, int n2,int j,int bits,int cpog_count){ int ones,bit_diff,q; char *number; ones = 0; if(SET){ if(!DC_custom[i] && !DC_custom[j]){ bit_diff = n1 ^ n2; for(q = 0; q<bits; q++){ if(bit_diff & 1) ones++; bit_diff >>= 1; } return ones; } if(DC_custom[i] && !DC_custom[j]){ print_binary(NULL,n2, bits); number = numb; ones = 0; char str[MAX_NAME]; int_to_string_DC(bits, i, n1, str); for(q = 0; q<bits; q++){ if(str[q] == '0' && number[q] == '1') ones++; if(str[q] == '1' && number[q] == '0') ones++; } return ones; } if(!DC_custom[i] && DC_custom[j]){ print_binary(NULL,n1, bits); number = numb; char str[MAX_NAME]; int_to_string_DC(bits, j, n2, str); for(q = 0; q<bits; q++){ if(str[q] == '0' && number[q] == '1') ones++; if(str[q] == '1' && number[q] == '0') ones++; } return ones; } if(DC_custom[i] && DC_custom[j]){ char str[MAX_NAME], str2[MAX_NAME]; int_to_string_DC(bits, i, n1, str); int_to_string_DC(bits, j, n2, str2); for(q = 0; q<bits; q++){ if(str[q] == '0' && str2[q] == '1') ones++; if(str[q] == '1' && str2[q] == '0') ones++; } return ones; } }
void challenge_34() { gmp_randstate_t *state = gmp_rand(); mpz_t p, g, a, A, b, B; unsigned char server_key[16], client_key[16]; unsigned char server_ct[256] = {0}, client_ct[256] = {0}; unsigned char server_iv[16], client_iv[16]; unsigned char message[128] = "this is a message of 30 bytes."; int mlen = 30, ctlen_server, ctlen_client, ptlen; fill_random_bytes(server_iv, 16); fill_random_bytes(client_iv, 16); // ServerKeyExchange: // Sends generated p, g, A dh_params(p, g); dh_keyexchange(state, p, g, a, A); // MITM relays p, g, and p instead of A // ClientKeyExchange: // Send generated B dh_keyexchange(state, p, g, b, B); // MITM relays p instead of B // Finished (server): // Received p from client, sends iv + encrypted message dh_finished(p, p, a, server_key); ctlen_server = encrypt_AES_CBC(message, server_ct, mlen, server_key, server_iv); // MITM relays as is // Finished (client): // Received p from server, sends iv + encrypted message dh_finished(p, p, b, client_key); ctlen_client = encrypt_AES_CBC(message, client_ct, mlen, client_key, client_iv); // MITM relays as is // Key should now be kdf(0), since // p mod p = 0 and 0^a = 0^b = 0 unsigned char mitm_key[16]; unsigned char pt[256] = {0}; dh_kdf_from_ui(0, mitm_key); ptlen = decrypt_AES_CBC(server_ct, pt, ctlen_server, mitm_key, server_iv); print_str("Recovered plaintext from server message:"); print_binary(pt, ptlen); memset(pt, 0, 256); ptlen = decrypt_AES_CBC(client_ct, pt, ctlen_client, mitm_key, client_iv); print_str("Recovered plaintext from client message:"); print_binary(pt, ptlen); dh_cleanup(state, p, g, a, A, b, B); }
int main(void) { int i; uint8_t payload[] = {0x18, 0x80, 0x81, 0x01}; uint8_t * payload_new = (uint8_t *)malloc(sizeof(uint8_t) * 4); for(i=0;i<4;i++) { payload_new[i] = reverse_bit_order(payload[i]); } for(i=0;i<4;i++) { printf("%d: old=0x%02X (%s)", i, payload[i], print_binary(payload[i])); printf(" -> new=0x%02X (%s)\n", payload_new[i], print_binary(payload_new[i])); } }
// The inverse table void print_index_of() { int i; for (i=0; i<=NN; i++) printf("%s = a^%d\n",print_binary(i, MM), index_of[i]); }
int main(int argc, char* argv[]) { if (argc != 2) { perror("arg not enough:"); exit(1); } int ret; char* str; char res[128]; struct in_addr addr; if ((ret = inet_pton(AF_INET, argv[1], &addr)) == 0) { perror("inet_pton:"); exit(1); } printf("%d\n",addr.s_addr); print_binary(addr.s_addr); str = inet_ntop(AF_INET, &addr, res, sizeof(res)); if ( str == NULL) { perror("inet_ntop:"); exit(1); } printf("%s\n", res); exit(0); }
void challenge_39() { mpz_t n, e, d; char *p_str = "38b689c351cf329d5efd5676b"; char *q_str = "54060a750a88d007bd41db2cb"; rsa_keygen(p_str, q_str, n, e, d); size_t pt_len = 32, ct_len = 0; unsigned char pt[200] = "yellow submarineyellow submarine"; unsigned char ct[200] = {0}; mpz_out_str(stdout, 16, n); printf("\n"); mpz_out_str(stdout, 16, e); printf("\n"); mpz_out_str(stdout, 16, d); printf("\n"); rsa_encrypt(pt, pt_len, ct, ct_len, n, e); memset(pt, 0, 32); rsa_decrypt(ct, ct_len, pt, pt_len, n, d); printf("Plaintext length: %ld\n", pt_len); print_binary(pt, pt_len); }
// just print the binary representation of the GF(2^MM) field // for debugging void print_alpha_to() { int i; for (i=0; i<=NN; i++) printf("a^%3d = %s\n",i, print_binary(alpha_to[i], MM)); }
int main(void) { printf("Enter a number\n"); unsigned n; while (scanf("%u", &n) == 1) { printf("Received:\t"); print_binary(n); printf("\nNext smallest:\t"); print_binary(next_smallest(n)); printf("\nNext largest:\t"); print_binary(next_largest(n)); printf("\n"); } return 0; }
int main(void) { printf("Enter N, M, j, and i\n"); unsigned N, M, j, i; while (scanf("%u%u%u%u", &N, &M, &j, &i) == 4) { printf("N =\t\t"); print_binary(N); printf("\nM =\t\t"); print_binary(M); printf("\nResult =\t"); print_binary(insert_into(N, M, j, i)); printf("\n"); } return 0; }
void print_bitmap(bitmap_t* bitmap) { for (unsigned row=0; row<bitmap->height; ++row) { printf("%3i ",row); for (unsigned int col = 0; col<bitmap->rowwidth; ++col) { print_binary(bitmap->data[row*bitmap->rowwidth+col], col == bitmap->rowwidth -1 ? bitmap->width % 8 : 8); } printf("\n"); } }
void trace_event(union perf_event *event) { unsigned char *raw_event = (void *)event; if (!dump_trace) return; print_binary(raw_event, event->header.size, 16, trace_event_printer, event); }
void loadScenarioOpcodes(int index){ scenarioOpcodes.resize(cpog_count); clear_scenarios(); for(int i = 0; i < cpog_count; i++){ print_binary(NULL, perm[index][i], bits); scenarioOpcodes[i] = string(numb); } return; }
void print_memory() { int i; for(i = 0; i < globals.mem_size; i++) { int lbln = label_find_by_value(i); if(lbln != -1) { printf("// %s\n", globals.labels[lbln].name); } if(globals.mem[i].valid) { if(globals.mem[i].is_literal) { int l; if(globals.mem[i].is_reference) { l = globals.labels[globals.mem[i].literal].value; if(l == -1) { fprintf(stderr, "ERROR: found label with undefined value. Label name: %s\n", globals.labels[globals.mem[i].literal].name); } } else { l = globals.mem[i].literal; } print_binary(l, 8); putchar('\n'); print_binary((l >> 8), 8); } else { uint16_t tmp = (globals.mem[i].opcode << 9) | (globals.mem[i].op0 << 6) | (globals.mem[i].op1 << 3) | globals.mem[i].op2; print_binary(tmp, 8); putchar('\n'); print_binary((tmp >> 8), 8); } }
int main(){ //declaration and user inputs number unsigned int user_input; printf("Enter an integer value: "); scanf("%u", &user_input); //declarations for sum output and a for loop value int sum_bits; int i=0; //so long as the value of user_input shifted count_digits to the right is not 0 while(i<VALUES){ //in this while loop I am going to iterate over the rightmost digit of the number sum_bits+= (user_input>>i)&1; //if the rightmost digit is 1, add 1 to sum_bits //otherwise, if the rightmost digit is 0, then this returns 0 and changes nothing if(i%2==1){ //make sure that the bit in that place is 1 user_input|=(1<<i); } i++; } printf("The number of bits that are equal to 1 is %d\n", sum_bits); printf("After setting odd-bits to 1: "); print_binary(user_input); int j=0; while(j<VALUES){ if(j%2==0){ //clear the bit from that place //note: ~(1<<j) contains 1111111011111 with the 0 in the jth position only user_input &= ~(1<<j); } j++; } printf("\nAfter clearing even-bits: "); print_binary(user_input); printf("\n"); return 0; }
//returns x with the bits n+p..p bits replaced with the rightmost //n bits of y. int setbits(int x, int p, int n, int y) { //bit positions are 32..0 from left to right. int mask; int y_bits; //make a mask to clear out the n bits. mask = ~((~(~0 << n)) << p); printf("Mask "); print_binary(mask); //now collect relevant bits from y. y_bits = ( ~((~0)<< n) & y) << p; printf("y_bits "); print_binary(y_bits); printf("x&mask "); print_binary(x&mask); return (x & mask) | y_bits; }
void binary_clock_draw(struct screen* display, struct time* time, int skin){ int lines_values[]={ time->hour,time->minute,time->second }; char buffer[9]; int i; const struct picture* binary_bitmaps = &(binary_skin[skin][display->screen_type]); int y_offset=(display->getheight()-(binary_bitmaps->slide_height*3))/2; int x_offset=(display->getwidth()-(binary_bitmaps->width*6))/2; for(i=0;i<3;i++){ print_binary(buffer, lines_values[i], 6); draw_string(display, binary_bitmaps, buffer, x_offset, binary_bitmaps->slide_height*i+y_offset); } }
/* lpm_insert: * Insert a new prefix ('ip_string' and 'netmask') into the tree. If * 'ip_string' does not contain a valid IPv4 address, or the netmask * is clearly invalid, the tree is not modified and the function * returns 0. Successful insertion returns 1. */ int lpm_insert(struct lpm_tree* tree, char* ip_string, uint32_t netmask) { struct sockaddr_storage *prefix = (struct sockaddr_storage *)malloc(sizeof(struct sockaddr_storage)); struct sockaddr_in6 *prefix6 = (struct sockaddr_in6 *)prefix; struct sockaddr_in *prefix4 = (struct sockaddr_in *) prefix; if (inet_pton(AF_INET6, ip_string, &prefix6->sin6_addr) == 1 && netmask <= MAX_BITS6) { prefix->ss_family = AF_INET6; char buffer[129]; memset(buffer, '\0', 129); printf("%s\n", print_binary((uint8_t *)&prefix6->sin6_addr, sizeof(prefix6->sin6_addr), buffer, 129)); DEBUG(">> Inserting %s/%d ========\n", ip_string, netmask); insert(prefix, netmask, tree->head); DEBUG(">> Done inserting %s/%d ===\n", ip_string, netmask); return 1; } else if (inet_pton(AF_INET, ip_string, &prefix4->sin_addr) == 1 && netmask <= MAX_BITS4) { prefix4->sin_family = AF_INET; prefix4->sin_addr.s_addr = htonl(prefix4->sin_addr.s_addr); char buffer[33]; memset(buffer, '\0', 33); printf("%s\n", print_binary((uint8_t *)&prefix4->sin_addr, sizeof(prefix4->sin_addr), buffer, 32)); DEBUG(">> Inserting %s/%d ========\n", ip_string, netmask); insert(prefix, netmask, tree->head); DEBUG(">> Done inserting %s/%d ===\n", ip_string, netmask); return 1; } return 0; }
int main() { int binary_number_1,binary_number_2,binary_number_3; printf("Please enter a value for A\r\n"); while( scanf("%d",&binary_number_1) != 1) { fflush(stdin); } printf("Please enter a value for B\r\n"); while( scanf("%d",&binary_number_2) != 1) { fflush(stdin); } printf("Please enter a value for C\r\n"); while( scanf("%d",&binary_number_3) != 1) { fflush(stdin); } printf("first binary number="); print_binary(binary_number_1); printf("\r\n"); printf("second binary number="); print_binary(binary_number_2); printf("\r\n"); printf("third binary number="); print_binary(binary_number_3); printf("\r\n"); return 0; }
/* debug_print: * Prints out the current node's parent, the current node's value (if * it has one), and recurses down to the left then right children. The * 'left' parameter should indicate the direction of the hop to the * current node (1 if the left child was used, 0 if the right child * was used; -1 is used to indicate the root of the tree.) */ void debug_print(struct internal_node* parent, int left, int depth, struct internal_node* n) { printf("parent:%p", (void*)parent); if (left == 1) { printf("->L"); } else if (left == 0) { printf("->R"); } else { printf("---"); } if (n == NULL) { printf(" Reached a null bottom %p\n", (void*)n); return; } else if (n->type == INT_NODE) { printf(" Internal node %p.\n", (void*)n); } else { struct data_node* node = (struct data_node*)n; char output[INET6_ADDRSTRLEN]; memset(output, 0, INET6_ADDRSTRLEN); struct sockaddr_storage *addr = node->prefix; switch (addr->ss_family) { case AF_INET6: { struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr; inet_ntop(AF_INET6, &addr6->sin6_addr, output, INET6_ADDRSTRLEN); break; } case AF_INET: { struct sockaddr_in *addr4 = (struct sockaddr_in *)addr; inet_ntop(AF_INET, &addr4->sin_addr, output, INET6_ADDRSTRLEN); char buffer[33]; memset(buffer, '\0', 33); printf("%s\n", print_binary((uint8_t *)&addr4->sin_addr, sizeof(addr4->sin_addr), buffer, 33)); break; } } printf(" External node: %p, %s/%d\n", (void*)n, output, node->netmask); } debug_print(n, 1, depth+1, n->l); debug_print(n, 0, depth+1, n->r); }
/* Render a value to text. */ static char *print_value(cJSON *item,int depth) { char *out=0; if (!item) return 0; switch ((item->type)&255) { case cJSON_NULL: out=cJSON_strdup(""); break; case cJSON_False: out=cJSON_strdup("false");break; case cJSON_True: out=cJSON_strdup("true"); break; case cJSON_Number: out=print_number(item);break; case cJSON_String: out=print_string(item);break; case cJSON_Array: out=print_array(item,depth);break; case cJSON_Object: out=print_object(item,depth);break; case cJSON_Binary: out=print_binary(item,depth); break; } return out; }
int timer_display_conf(unsigned char conf) { printf("Status byte: "); print_binary(conf); printf("\n"); printf("Output: %d\n", (conf & TIMER_STATUS_OUTPUT) >> TIMER_STATUS_OUTPUT_BIT); printf("Null count: %d\n", (conf & TIMER_STATUS_NULL) >> TIMER_STATUS_NULL_BIT); printf("Type of access: "); switch (conf & TIMER_LSB_MSB) { case TIMER_LSB: printf("LSB\n"); break; case TIMER_MSB: printf("MSB\n"); break; case TIMER_LSB_MSB: printf("LSB followed by MSB\n"); break; default: printf("Unknown\n"); } printf("Operating mode: "); switch (conf & (TIMER_RATE_GEN | TIMER_SQR_WAVE)) { case TIMER_RATE_GEN: printf("rate generator\n"); break; case TIMER_SQR_WAVE: printf("square wave generator\n"); break; default: printf("Unknown\n"); } printf("Counting mode: "); if ((conf & TIMER_BCD) == TIMER_BCD) { printf("BCD\n"); } else { printf("binary\n"); } return 0; }
TEST_F(Helium_100_Test, InterpretFunctionConfig) { //unsigned char * config_value = (unsigned char *)0b0111110111011111; printf("Size of function_config: %d \r\n", CFG_FUNCTION_CONFIG_LENGTH); int config_value = 0x7ddf; int config2_value = 0x0000; struct function_config fc1; print_binary(config_value); memcpy (&fc1,&config_value,CFG_FUNCTION_CONFIG_LENGTH); ASSERT_EQ(0,fc1.beacon_0); ASSERT_EQ(CFG_FC_BEACON_CODE_RESET_ON,fc1.beacon_oa_cmd_status); ASSERT_EQ(CFG_FC_BEACON_CODE_UPLOAD_ON,fc1.beacon_code_upload_status); ASSERT_EQ(CFG_FC_BEACON_OA_COMMANDS_ON,fc1.beacon_radio_reset_status); ASSERT_EQ(CFG_FC_TELEMETRY_DUMP_ON,fc1.telemetry_status); ASSERT_EQ(CFG_FC_TELEMETRY_RATE_2HZ,fc1.telemetry_rate); // TODO BROKEN ASSERT_EQ(CFG_FC_TELEMETRY_ON,fc1.telemetry_dump_status); // TODO BROKEN ASSERT_EQ(CFG_FC_TX_CRC_ON,fc1.crc_rx); ASSERT_EQ(CFG_FC_RX_CRC_ON,fc1.crc_tx); ASSERT_EQ(CFG_FC_PIN14_DIOOVERAIR_ON,fc1.pin14); ASSERT_EQ(CFG_FC_PIN13_RXPACKETTOG,fc1.pin13); ASSERT_EQ(CFG_FC_LED_RXTOG,fc1.led); /* struct function_config fc1_comp; fc1_comp.led = CFG_FC_LED_RXTOG; fc1_comp.pin13 = CFG_FC_PIN13_RXPACKETTOG; fc1_comp.beacon_0 = 0; struct function_config2 fc2; print_binary(config2_value); memcpy (&fc2,&config2_value,CFG_FUNCTION_CONFIG2_LENGTH); ASSERT_EQ(0,fc2.t0); ASSERT_EQ(0,fc2.t4); ASSERT_EQ(0,fc2.t8); ASSERT_EQ(0,fc2.tbd); ASSERT_EQ(0,fc2.txcw); ASSERT_EQ(0,fc2.rxcw); ASSERT_EQ(0,fc2.rafc); */ }
// Poke void poke(const char * reg, unsigned int value) { // Initialize skiroc2_slow_control_init(); // Poke skiroc2_slow_control_poke(reg, value); // Peek value = skiroc2_slow_control_peek(reg); printf("%s ", reg); print_binary(value); printf("\n"); // Write to file dump_register_to_file(); return; }
void challenge_30() { unsigned char message[128] = "comment1=cooking%20MCs;userdata=foo;" "comment2=%20like%20a%20pound%20of%20bacon"; int mlen = 77, plen; unsigned char padded_message[256] = {0}; memcpy(padded_message, message, 128); unsigned char append[16] = ";admin=true"; int alen = 11; unsigned char mac[16], forged_mac[16], test_mac[16]; print_str("Base MAC"); md4_keyed_mac(message, strlen((char *) message), (unsigned char *) get_static_word(), strlen(get_static_word()), mac); print_hex(mac, 16); print_str("\nForged MAC"); // Assumes secret length 8, but will be the same for any // secret length that doesn't increase or decrease the // number of 64 byte blocks in the hash input + padding md4_length_extension(mac, mlen + 8 + sha1_pad_length(mlen + 8), append, alen, forged_mac); print_hex(forged_mac, 16); print_str("\nPlaintext verified by server: "); int i; for (i = 0; i < 16; ++i) { plen = md4_pad(padded_message, mlen, i); memcpy(padded_message + plen, append, alen); plen += alen; md4_keyed_mac(padded_message, plen, (unsigned char *) get_static_word(), strlen(get_static_word()), test_mac); //print_hex(test_mac, 16); //print_binary(padded_message, plen); if (memcmp(forged_mac, test_mac, 16) == 0) { print_hex(test_mac, 16); print_binary(padded_message, plen); } } }
unsigned int print_it(t_tmp_arg *tmp, t_params *params, char c, unsigned int chars_to_save) { unsigned int wt; wt = 0; (c == 'd') ? (wt = print_int(tmp, params, 0, 0)) : (0); (c == 'i') ? (wt = print_int(tmp, params, 0, 0)) : (0); (c == 'u') ? (wt = print_uint(tmp, params, 0, 0)) : (0); (c == 'x') ? (wt = print_little_hexa(tmp, params, 0, 0)) : (0); (c == 'X') ? (wt = print_large_hexa(tmp, params, 0, 0)) : (0); (c == 'n') ? (wt = save_chars(tmp, chars_to_save)) : (0); (c == 'o') ? (wt = print_octal(tmp, params, 0, 0)) : (0); (c == 'c') ? (wt = print_char(tmp, params, 0, 0)) : (0); (c == 's') ? (wt = print_str(tmp, params, 0, 0)) : (0); (c == '%') ? (wt = print_percent()) : (0); (c == 'S') ? (wt = print_all_str(tmp, params, 0, 0)) : (0); (c == 'p') ? (wt = print_ptr(tmp, params, 0, 0)) : (0); (c == 'b') ? (wt = print_binary(tmp, params, 0, 0)) : (0); return (wt); }
static void print_file(const sc_file_t *file) { const char *st; if (file->type == SC_FILE_TYPE_DF) printf("["); else printf(" "); printf("%02X%02X", file->id >> 8, file->id & 0xFF); if (file->type == SC_FILE_TYPE_DF) printf("]"); else printf(" "); switch (file->type) { case SC_FILE_TYPE_WORKING_EF: st = "wEF"; break; case SC_FILE_TYPE_INTERNAL_EF: st = "iEF"; break; case SC_FILE_TYPE_DF: st = "DF"; break; default: st = "???"; break; } printf("\t%4s", st); printf(" %5lu", (unsigned long)file->size); if (file->namelen) { printf("\tName: "); print_binary(stdout, file->name, file->namelen); } printf("\n"); return; }
int main() { enumerate_broken_digits(); int T; scanf("%d", &T); for (int i = 1; i <= T; i++) { int N; scanf("%d", &N); int d[N]; for (int j = 0; j < N; j++) { d[j] = read_binary(); } printf("Case #%d: ", i); int next; if (N > 10) { int j; for (j = 0; j < N; j++) { if (d[j] != d[j % 10]) { printf("ERROR!\n"); break; } } if (j != N) continue; next = next_state(&d[N-10], 10); } else { next = next_state(d, N); } if (next < 0) printf("ERROR!\n"); else { print_binary(next); printf("\n"); } } return 0; }
static inline int print_value(FILE *fd, int type, struct rtattr *rta) { if (rta == NULL) { fprintf(stderr, "Missing value TLV\n"); return -1; } switch(type) { case TCF_META_TYPE_INT: if (RTA_PAYLOAD(rta) < sizeof(__u32)) { fprintf(stderr, "meta int type value TLV " \ "size mismatch.\n"); return -1; } fprintf(fd, "%d", rta_getattr_u32(rta)); break; case TCF_META_TYPE_VAR: print_binary(fd, RTA_DATA(rta), RTA_PAYLOAD(rta)); break; } return 0; }
static int fingerprint_test_vector() { pj_pool_t *pool; pj_status_t status; unsigned i; int rc = 0; /* To avoid function not referenced warnings */ (void)create_msgint2; (void)create_msgint3; PJ_LOG(3,(THIS_FILE, " draft-denis-behave-rfc3489bis-test-vectors-02")); pool = pj_pool_create(mem, "fingerprint", 1024, 1024, NULL); for (i=0; i<PJ_ARRAY_SIZE(test_vectors); ++i) { struct test_vector *v; pj_stun_msg *ref_msg, *msg; pj_size_t parsed_len; pj_size_t len; unsigned pos; pj_uint8_t buf[1500]; char print[1500]; pj_str_t key; PJ_LOG(3,(THIS_FILE, " Running test %d/%d", i, PJ_ARRAY_SIZE(test_vectors))); v = &test_vectors[i]; /* Print reference message */ PJ_LOG(4,(THIS_FILE, "Reference message PDU:\n%s", print_binary((pj_uint8_t*)v->pdu, v->pdu_len))); /* Try to parse the reference message first */ status = pj_stun_msg_decode(pool, (pj_uint8_t*)v->pdu, v->pdu_len, PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET, &ref_msg, &parsed_len, NULL); if (status != PJ_SUCCESS) { PJ_LOG(1,(THIS_FILE, " Error decoding reference message")); rc = -1010; goto on_return; } if (parsed_len != v->pdu_len) { PJ_LOG(1,(THIS_FILE, " Parsed len error")); rc = -1020; goto on_return; } /* Print the reference message */ pj_stun_msg_dump(ref_msg, print, sizeof(print), NULL); PJ_LOG(4,(THIS_FILE, "Reference message:\n%s", print)); /* Create our message */ msg = v->create(pool, v); if (msg == NULL) { PJ_LOG(1,(THIS_FILE, " Error creating stun message")); rc = -1030; goto on_return; } /* Encode message */ if (v->options & USE_MESSAGE_INTEGRITY) { pj_str_t s1, s2, r; pj_stun_create_key(pool, &key, pj_cstr(&r, v->realm), pj_cstr(&s1, v->username), PJ_STUN_PASSWD_PLAIN, pj_cstr(&s2, v->password)); pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len); } else { pj_stun_msg_encode(msg, buf, sizeof(buf), 0, NULL, &len); } /* Print our raw message */ PJ_LOG(4,(THIS_FILE, "Message PDU:\n%s", print_binary((pj_uint8_t*)buf, len))); /* Print our message */ pj_stun_msg_dump(msg, print, sizeof(print), NULL); PJ_LOG(4,(THIS_FILE, "Message is:\n%s", print)); /* Compare message length */ if (len != v->pdu_len) { PJ_LOG(1,(THIS_FILE, " Message length mismatch")); rc = -1050; goto on_return; } pos = cmp_buf(buf, (const pj_uint8_t*)v->pdu, len); if (pos != (unsigned)-1) { PJ_LOG(1,(THIS_FILE, " Message mismatch at byte %d", pos)); rc = -1060; goto on_return; } /* Authenticate the request/response */ if (v->options & USE_MESSAGE_INTEGRITY) { if (PJ_STUN_IS_REQUEST(msg->hdr.type)) { pj_stun_auth_cred cred; pj_status_t status; pj_bzero(&cred, sizeof(cred)); cred.type = PJ_STUN_AUTH_CRED_STATIC; cred.data.static_cred.realm = pj_str(v->realm); cred.data.static_cred.username = pj_str(v->username); cred.data.static_cred.data = pj_str(v->password); cred.data.static_cred.nonce = pj_str(v->nonce); status = pj_stun_authenticate_request(buf, len, msg, &cred, pool, NULL, NULL); if (status != PJ_SUCCESS) { char errmsg[PJ_ERR_MSG_SIZE]; pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1,(THIS_FILE, " Request authentication failed: %s", errmsg)); rc = -1070; goto on_return; } } else if (PJ_STUN_IS_RESPONSE(msg->hdr.type)) { pj_status_t status; status = pj_stun_authenticate_response(buf, len, msg, &key); if (status != PJ_SUCCESS) { char errmsg[PJ_ERR_MSG_SIZE]; pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1,(THIS_FILE, " Response authentication failed: %s", errmsg)); rc = -1080; goto on_return; } } } } on_return: pj_pool_release(pool); return rc; }