// The main program.
int main (int argc, char** argv)
{
// Skip adaptive examples on a non-adaptive libMesh build
#ifndef LIBMESH_ENABLE_AMR
libmesh_example_assert(false, "--enable-amr");
#else
// Skip this 2D example if libMesh was compiled as 1D-only.
libmesh_example_assert(2 <= LIBMESH_DIM, "2D support");
// Initialize libMesh.
LibMeshInit init (argc, argv);
std::cout << "Started " << argv[0] << std::endl;
// Make sure the general input file exists, and parse it
{
std::ifstream i("general.in");
if (!i)
{
std::cerr << '[' << init.comm().rank()
<< "] Can't find general.in; exiting early."
<< std::endl;
libmesh_error();
}
}
GetPot infile("general.in");
// Read in parameters from the input file
FEMParameters param;
param.read(infile);
// Create a mesh with the given dimension, distributed
// across the default MPI communicator.
Mesh mesh(init.comm(), param.dimension);
// And an object to refine it
AutoPtr<MeshRefinement> mesh_refinement(new MeshRefinement(mesh));
// And an EquationSystems to run on it
EquationSystems equation_systems (mesh);
std::cout << "Building mesh" << std::endl;
// Build a unit square
ElemType elemtype;
if (param.elementtype == "tri" ||
param.elementtype == "unstructured")
elemtype = TRI3;
else
elemtype = QUAD4;
MeshTools::Generation::build_square
(mesh, param.coarsegridx, param.coarsegridy,
param.domain_xmin, param.domain_xmin + param.domain_edge_width,
param.domain_ymin, param.domain_ymin + param.domain_edge_length,
elemtype);
std::cout << "Building system" << std::endl;
HeatSystem &system = equation_systems.add_system<HeatSystem> ("HeatSystem");
set_system_parameters(system, param);
std::cout << "Initializing systems" << std::endl;
// Initialize the system
equation_systems.init ();
// Refine the grid again if requested
for (unsigned int i=0; i != param.extrarefinements; ++i)
{
mesh_refinement->uniformly_refine(1);
equation_systems.reinit();
}
std::cout<<"Setting primal initial conditions"<<std::endl;
read_initial_parameters();
system.project_solution(initial_value, initial_grad,
equation_systems.parameters);
// Output the H1 norm of the initial conditions
libMesh::out << "|U(" <<system.time<< ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl<<std::endl;
// Add an adjoint vector, this will be computed after the forward
// time stepping is complete
//
// Tell the library not to save adjoint solutions during the forward
// solve
//
// Tell the library not to project this vector, and hence, memory
// solution history to not save it.
//
// Make this vector ghosted so we can localize it to each element
// later.
const std::string & adjoint_solution_name = "adjoint_solution0";
system.add_vector("adjoint_solution0", false, GHOSTED);
// Close up any resources initial.C needed
finish_initialization();
// Plot the initial conditions
write_output(equation_systems, 0, "primal");
// Print information about the mesh and system to the screen.
mesh.print_info();
equation_systems.print_info();
// In optimized mode we catch any solver errors, so that we can
// write the proper footers before closing. In debug mode we just
// let the exception throw so that gdb can grab it.
#ifdef NDEBUG
try
{
#endif
// Now we begin the timestep loop to compute the time-accurate
// solution of the equations.
for (unsigned int t_step=param.initial_timestep;
t_step != param.initial_timestep + param.n_timesteps; ++t_step)
{
// A pretty update message
std::cout << " Solving time step " << t_step << ", time = "
<< system.time << std::endl;
// Solve the forward problem at time t, to obtain the solution at time t + dt
system.solve();
// Output the H1 norm of the computed solution
libMesh::out << "|U(" <<system.time + system.deltat<< ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl;
// Advance to the next timestep in a transient problem
std::cout<<"Advancing timestep"<<std::endl<<std::endl;
system.time_solver->advance_timestep();
// Write out this timestep
write_output(equation_systems, t_step+1, "primal");
}
// End timestep loop
///////////////// Now for the Adjoint Solution //////////////////////////////////////
// Now we will solve the backwards in time adjoint problem
std::cout << std::endl << "Solving the adjoint problem" << std::endl;
// We need to tell the library that it needs to project the adjoint, so
// MemorySolutionHistory knows it has to save it
// Tell the library to project the adjoint vector, and hence, memory solution history to
// save it
system.set_vector_preservation(adjoint_solution_name, true);
std::cout << "Setting adjoint initial conditions Z("<<system.time<<")"<<std::endl;
// Need to call adjoint_advance_timestep once for the initial condition setup
std::cout<<"Retrieving solutions at time t="<<system.time<<std::endl;
system.time_solver->adjoint_advance_timestep();
// Output the H1 norm of the retrieved solutions (u^i and u^i+1)
libMesh::out << "|U(" <<system.time + system.deltat<< ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl;
libMesh::out << "|U(" <<system.time<< ")|= " << system.calculate_norm(system.get_vector("_old_nonlinear_solution"), 0, H1) << std::endl;
// The first thing we have to do is to apply the adjoint initial
// condition. The user should supply these. Here they are specified
// in the functions adjoint_initial_value and adjoint_initial_gradient
system.project_vector(adjoint_initial_value, adjoint_initial_grad, equation_systems.parameters, system.get_adjoint_solution(0));
// Since we have specified an adjoint solution for the current time (T), set the adjoint_already_solved boolean to true, so we dont solve unneccesarily in the adjoint sensitivity method
system.set_adjoint_already_solved(true);
libMesh::out << "|Z(" <<system.time<< ")|= " << system.calculate_norm(system.get_adjoint_solution(), 0, H1) << std::endl<<std::endl;
write_output(equation_systems, param.n_timesteps, "dual");
// Now that the adjoint initial condition is set, we will start the
// backwards in time adjoint integration
// For loop stepping backwards in time
for (unsigned int t_step=param.initial_timestep;
t_step != param.initial_timestep + param.n_timesteps; ++t_step)
{
//A pretty update message
std::cout << " Solving adjoint time step " << t_step << ", time = "
<< system.time << std::endl;
// The adjoint_advance_timestep
// function calls the retrieve function of the memory_solution_history
// class via the memory_solution_history object we declared earlier.
// The retrieve function sets the system primal vectors to their values
// at the current timestep
std::cout<<"Retrieving solutions at time t="<<system.time<<std::endl;
system.time_solver->adjoint_advance_timestep();
// Output the H1 norm of the retrieved solution
libMesh::out << "|U(" <<system.time + system.deltat << ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl;
libMesh::out << "|U(" <<system.time<< ")|= " << system.calculate_norm(system.get_vector("_old_nonlinear_solution"), 0, H1) << std::endl;
system.set_adjoint_already_solved(false);
system.adjoint_solve();
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true, so we dont solve unneccesarily in the error estimator
system.set_adjoint_already_solved(true);
libMesh::out << "|Z(" <<system.time<< ")|= "<< system.calculate_norm(system.get_adjoint_solution(), 0, H1) << std::endl << std::endl;
// Get a pointer to the primal solution vector
NumericVector<Number> &primal_solution = *system.solution;
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> &dual_solution_0 = system.get_adjoint_solution(0);
// Swap the primal and dual solutions so we can write out the adjoint solution
primal_solution.swap(dual_solution_0);
write_output(equation_systems, param.n_timesteps - (t_step + 1), "dual");
// Swap back
primal_solution.swap(dual_solution_0);
}
// End adjoint timestep loop
// Now that we have computed both the primal and adjoint solutions, we compute the sensitivties to the parameter p
// dQ/dp = partialQ/partialp - partialR/partialp
// partialQ/partialp = (Q(p+dp) - Q(p-dp))/(2*dp), this is not supported by the library yet
// partialR/partialp = (R(u,z;p+dp) - R(u,z;p-dp))/(2*dp), where
// R(u,z;p+dp) = int_{0}^{T} f(z;p+dp) - <partialu/partialt, z>(p+dp) - <g(u),z>(p+dp)
// To do this we need to step forward in time, and compute the perturbed R at each time step and accumulate it
// Then once all time steps are over, we can compute (R(u,z;p+dp) - R(u,z;p-dp))/(2*dp)
// Now we begin the timestep loop to compute the time-accurate
// adjoint sensitivities
for (unsigned int t_step=param.initial_timestep;
t_step != param.initial_timestep + param.n_timesteps; ++t_step)
{
// A pretty update message
std::cout << "Retrieving " << t_step << ", time = "
<< system.time << std::endl;
// Retrieve the primal and adjoint solutions at the current timestep
system.time_solver->retrieve_timestep();
libMesh::out << "|U(" <<system.time + system.deltat << ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl;
libMesh::out << "|U(" <<system.time<< ")|= " << system.calculate_norm(system.get_vector("_old_nonlinear_solution"), 0, H1) << std::endl;
libMesh::out << "|Z(" <<system.time<< ")|= "<< system.calculate_norm(system.get_adjoint_solution(0), 0, H1) << std::endl << std::endl;
// Call the postprocess function which we have overloaded to compute
// accumulate the perturbed residuals
(dynamic_cast<HeatSystem&>(system)).perturb_accumulate_residuals(dynamic_cast<HeatSystem&>(system).get_parameter_vector());
// Move the system time forward (retrieve_timestep does not do this)
system.time += system.deltat;
}
// A pretty update message
std::cout << "Retrieving " << " final time = "
<< system.time << std::endl;
// Retrieve the primal and adjoint solutions at the current timestep
system.time_solver->retrieve_timestep();
libMesh::out << "|U(" <<system.time + system.deltat << ")|= " << system.calculate_norm(*system.solution, 0, H1) << std::endl;
libMesh::out << "|U(" <<system.time<< ")|= " << system.calculate_norm(system.get_vector("_old_nonlinear_solution"), 0, H1) << std::endl;
libMesh::out << "|Z(" <<system.time<< ")|= "<< system.calculate_norm(system.get_adjoint_solution(0), 0, H1) << std::endl<<std::endl;
// Call the postprocess function which we have overloaded to compute
// accumulate the perturbed residuals
(dynamic_cast<HeatSystem&>(system)).perturb_accumulate_residuals(dynamic_cast<HeatSystem&>(system).get_parameter_vector());
// Now that we computed the accumulated, perturbed residuals, we can compute the
// approximate sensitivity
Number sensitivity_0_0 = (dynamic_cast<HeatSystem&>(system)).compute_final_sensitivity();
// Print it out
std::cout<<"Sensitivity of QoI 0 w.r.t parameter 0 is: " << sensitivity_0_0 << std::endl;
#ifdef NDEBUG
}
catch (...)
{
std::cerr << '[' << mesh.processor_id()
<< "] Caught exception; exiting early." << std::endl;
}
#endif
std::cerr << '[' << mesh.processor_id()
<< "] Completing output." << std::endl;
// All done.
return 0;
#endif // LIBMESH_ENABLE_AMR
}
int main(int argc, char **argv)
{
int port = 0;
int messagenumber = 5;
char local_addr[256];
int c;
int mclient = 1;
char peer_address[129] = "\0";
int peer_port = PEER_DEFAULT_PORT;
char rest_api_separator = ':';
int use_null_cipher=0;
set_logfile("stdout");
set_execdir();
set_system_parameters(0);
ns_bzero(local_addr, sizeof(local_addr));
while ((c = getopt(argc, argv, "d:p:l:n:L:m:e:r:u:w:i:k:z:W:C:E:F:vsyhcxXgtTSAPDNOUHMRIGB")) != -1) {
switch (c){
case 'B':
random_disconnect = 1;
break;
case 'G':
extra_requests = 1;
break;
case 'F':
STRCPY(cipher_suite,optarg);
break;
case 'I':
no_permissions = 1;
break;
case 'M':
mobility = 1;
break;
case 'H':
shatype = SHATYPE_SHA256;
break;
case 'E':
{
char* fn = find_config_file(optarg,1);
if(!fn) {
fprintf(stderr,"ERROR: file %s not found\n",optarg);
exit(-1);
}
STRCPY(ca_cert_file,fn);
}
break;
case 'O':
dos = 1;
break;
case 'C':
rest_api_separator=*optarg;
break;
case 'D':
mandatory_channel_padding = 1;
break;
case 'N':
negative_test = 1;
break;
case 'R':
negative_protocol_test = 1;
break;
case 'z':
RTP_PACKET_INTERVAL = atoi(optarg);
break;
case 'A':
use_short_term = 1;
break;
case 'u':
STRCPY(g_uname, optarg);
break;
case 'w':
STRCPY(g_upwd, optarg);
break;
case 'g':
dont_fragment = 1;
break;
case 'd':
STRCPY(client_ifname, optarg);
break;
case 'x':
default_address_family = STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6;
break;
case 'X':
default_address_family = STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV4;
break;
case 'l':
clmessage_length = atoi(optarg);
break;
case 's':
do_not_use_channel = 1;
break;
case 'n':
messagenumber = atoi(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'L':
STRCPY(local_addr, optarg);
break;
case 'e':
STRCPY(peer_address, optarg);
break;
case 'r':
peer_port = atoi(optarg);
break;
case 'v':
clnet_verbose = TURN_VERBOSE_NORMAL;
break;
case 'h':
hang_on = 1;
break;
case 'c':
no_rtcp = 1;
break;
case 'm':
mclient = atoi(optarg);
break;
case 'y':
c2c = 1;
break;
case 't':
use_tcp = 1;
break;
case 'P':
passive_tcp = 1;
/* implies 'T': */
/* no break */
case 'T':
relay_transport = STUN_ATTRIBUTE_TRANSPORT_TCP_VALUE;
break;
case 'U':
use_null_cipher = 1;
/* implies 'S' */
/* no break */
case 'S':
use_secure = 1;
break;
case 'W':
g_use_auth_secret_with_timestamp = 1;
STRCPY(g_auth_secret,optarg);
break;
case 'i':
{
char* fn = find_config_file(optarg,1);
if(!fn) {
fprintf(stderr,"ERROR: file %s not found\n",optarg);
exit(-1);
}
STRCPY(cert_file,fn);
free(fn);
}
break;
case 'k':
{
char* fn = find_config_file(optarg,1);
if(!fn) {
fprintf(stderr,"ERROR: file %s not found\n",optarg);
exit(-1);
}
STRCPY(pkey_file,fn);
free(fn);
}
break;
default:
fprintf(stderr, "%s\n", Usage);
exit(1);
}
}
if(g_use_auth_secret_with_timestamp) {
if(use_short_term) {
fprintf(stderr,"ERROR: You cannot use authentication secret (REST API) with short-term credentials mechanism.\n");
exit(-1);
}
{
char new_uname[1025];
const unsigned long exp_time = 3600 * 24; /* one day */
if(g_uname[0]) {
snprintf(new_uname,sizeof(new_uname),"%lu%c%s",(unsigned long)time(NULL) + exp_time,rest_api_separator, (char*)g_uname);
} else {
snprintf(new_uname,sizeof(new_uname),"%lu", (unsigned long)time(NULL) + exp_time);
}
STRCPY(g_uname,new_uname);
}
{
u08bits hmac[MAXSHASIZE];
unsigned int hmac_len;
switch(shatype) {
case SHATYPE_SHA256:
hmac_len = SHA256SIZEBYTES;
break;
default:
hmac_len = SHA1SIZEBYTES;
};
hmac[0]=0;
if(stun_calculate_hmac(g_uname, strlen((char*)g_uname), (u08bits*)g_auth_secret, strlen(g_auth_secret), hmac, &hmac_len, shatype)>=0) {
size_t pwd_length = 0;
char *pwd = base64_encode(hmac,hmac_len,&pwd_length);
if(pwd) {
if(pwd_length>0) {
ns_bcopy(pwd,g_upwd,pwd_length);
g_upwd[pwd_length]=0;
}
}
free(pwd);
}
}
}
if(is_TCP_relay()) {
dont_fragment = 0;
no_rtcp = 1;
c2c = 1;
use_tcp = 1;
do_not_use_channel = 1;
}
if(port == 0) {
if(use_secure)
port = DEFAULT_STUN_TLS_PORT;
else
port = DEFAULT_STUN_PORT;
}
if (clmessage_length < (int) sizeof(message_info))
clmessage_length = (int) sizeof(message_info);
const int max_header = 100;
if(clmessage_length > (int)(STUN_BUFFER_SIZE-max_header)) {
fprintf(stderr,"Message length was corrected to %d\n",(STUN_BUFFER_SIZE-max_header));
clmessage_length = (int)(STUN_BUFFER_SIZE-max_header);
}
if (optind >= argc) {
fprintf(stderr, "%s\n", Usage);
exit(-1);
}
if (!c2c) {
if (make_ioa_addr((const u08bits*) peer_address, peer_port, &peer_addr) < 0)
return -1;
if(peer_addr.ss.sa_family == AF_INET6)
default_address_family = STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6;
}
/* SSL Init ==>> */
if(use_secure) {
SSL_load_error_strings();
OpenSSL_add_ssl_algorithms();
const char *csuite = "ALL"; //"AES256-SHA" "DH"
if(use_null_cipher)
csuite = "eNULL";
else if(cipher_suite[0])
csuite=cipher_suite;
if(use_tcp) {
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(SSLv23_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(SSLv3_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(TLSv1_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
#if defined(SSL_TXT_TLSV1_1)
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(TLSv1_1_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
#if defined(SSL_TXT_TLSV1_2)
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(TLSv1_2_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
#endif
#endif
} else {
#if defined(TURN_NO_DTLS)
fprintf(stderr,"ERROR: DTLS is not supported.\n");
exit(-1);
#else
if(OPENSSL_VERSION_NUMBER < 0x10000000L) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_WARNING, "WARNING: OpenSSL version is rather old, DTLS may not be working correctly.\n");
}
root_tls_ctx[root_tls_ctx_num] = SSL_CTX_new(DTLSv1_client_method());
SSL_CTX_set_cipher_list(root_tls_ctx[root_tls_ctx_num], csuite);
root_tls_ctx_num++;
#endif
}
int sslind = 0;
for(sslind = 0; sslind<root_tls_ctx_num; sslind++) {
if(cert_file[0]) {
if (!SSL_CTX_use_certificate_chain_file(root_tls_ctx[sslind], cert_file)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "\nERROR: no certificate found!\n");
exit(-1);
}
}
if (!SSL_CTX_use_PrivateKey_file(root_tls_ctx[sslind], pkey_file,
SSL_FILETYPE_PEM)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "\nERROR: no private key found!\n");
exit(-1);
}
if(cert_file[0]) {
if (!SSL_CTX_check_private_key(root_tls_ctx[sslind])) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "\nERROR: invalid private key!\n");
exit(-1);
}
}
if (ca_cert_file[0]) {
if (!SSL_CTX_load_verify_locations(root_tls_ctx[sslind], ca_cert_file, NULL )) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"ERROR: cannot load CA from file: %s\n",
ca_cert_file);
}
/* Set to require peer (client) certificate verification */
SSL_CTX_set_verify(root_tls_ctx[sslind], SSL_VERIFY_PEER, NULL );
/* Set the verification depth to 9 */
SSL_CTX_set_verify_depth(root_tls_ctx[sslind], 9);
} else {
SSL_CTX_set_verify(root_tls_ctx[sslind], SSL_VERIFY_NONE, NULL );
}
if(!use_tcp)
SSL_CTX_set_read_ahead(root_tls_ctx[sslind], 1);
}
}
start_mclient(argv[optind], port, client_ifname, local_addr, messagenumber, mclient);
return 0;
}
int main(int argc, const char **argv)
{
int res = -1;
UNUSED_ARG(argc);
UNUSED_ARG(argv);
if(argc>1)
print_extra = 1;
set_logfile("stdout");
set_system_parameters(0);
{
const unsigned char reqstc[] =
"\x00\x01\x00\x58"
"\x21\x12\xa4\x42"
"\xb7\xe7\xa7\x01\xbc\x34\xd6\x86\xfa\x87\xdf\xae"
"\x80\x22\x00\x10"
"STUN test client"
"\x00\x24\x00\x04"
"\x6e\x00\x01\xff"
"\x80\x29\x00\x08"
"\x93\x2f\xf9\xb1\x51\x26\x3b\x36"
"\x00\x06\x00\x09"
"\x65\x76\x74\x6a\x3a\x68\x36\x76\x59\x20\x20\x20"
"\x00\x08\x00\x14"
"\x9a\xea\xa7\x0c\xbf\xd8\xcb\x56\x78\x1e\xf2\xb5"
"\xb2\xd3\xf2\x49\xc1\xb5\x71\xa2"
"\x80\x28\x00\x04"
"\xe5\x7a\x3b\xcf";
u08bits buf[sizeof(reqstc)];
memcpy(buf, reqstc, sizeof(reqstc));
{//fingerprintfs etc
res = stun_is_command_message_full_check_str(buf, sizeof(reqstc) - 1, 1, NULL);
printf("RFC 5769 message fingerprint test(0) result: ");
if (res) {
printf("success\n");
} else if (res == 0) {
printf("failure on fingerprint(0) check\n");
exit(-1);
}
}
{//short-term credentials
u08bits uname[33];
u08bits realm[33];
u08bits upwd[33];
strcpy((char*) upwd, "VOkJxbRl1RmTxUk/WvJxBt");
res = stun_check_message_integrity_str(TURN_CREDENTIALS_SHORT_TERM, buf, sizeof(reqstc) - 1, uname, realm, upwd, shatype);
printf("RFC 5769 simple request short-term credentials and integrity test result: ");
if (res > 0) {
printf("success\n");
} else if (res == 0) {
printf("failure on integrity check\n");
exit(-1);
} else {
printf("failure on message structure check\n");
exit(-1);
}
}
{//negative fingerprint
buf[27] = 23;
res = stun_is_command_message_full_check_str(buf, sizeof(reqstc) - 1, 1, NULL);
printf("RFC 5769 NEGATIVE fingerprint test(0) result: ");
if (!res) {
printf("success\n");
} else if (res == 0) {
printf("failure on NEGATIVE fingerprint check\n");
exit(-1);
}
}
}
{
const unsigned char reqltc[] = "\x00\x01\x00\x60"
"\x21\x12\xa4\x42"
"\x78\xad\x34\x33\xc6\xad\x72\xc0\x29\xda\x41\x2e"
"\x00\x06\x00\x12"
"\xe3\x83\x9e\xe3\x83\x88\xe3\x83\xaa\xe3\x83\x83"
"\xe3\x82\xaf\xe3\x82\xb9\x00\x00"
"\x00\x15\x00\x1c"
"\x66\x2f\x2f\x34\x39\x39\x6b\x39\x35\x34\x64\x36"
"\x4f\x4c\x33\x34\x6f\x4c\x39\x46\x53\x54\x76\x79"
"\x36\x34\x73\x41"
"\x00\x14\x00\x0b"
"\x65\x78\x61\x6d\x70\x6c\x65\x2e\x6f\x72\x67\x00"
"\x00\x08\x00\x14"
"\xf6\x70\x24\x65\x6d\xd6\x4a\x3e\x02\xb8\xe0\x71"
"\x2e\x85\xc9\xa2\x8c\xa8\x96\x66";
u08bits user[] = "\xe3\x83\x9e\xe3\x83\x88\xe3\x83\xaa\xe3\x83\x83"
"\xe3\x82\xaf\xe3\x82\xb9";
u08bits realm[33];
u08bits nonce[29];
u08bits upwd[33];
u08bits buf[sizeof(reqltc)];
memcpy(buf, reqltc, sizeof(reqltc));
u08bits uname[sizeof(user)];
memcpy(uname, user, sizeof(user));
strcpy((char*) realm, "example.org");
strcpy((char*) upwd, "TheMatrIX");
strcpy((char*)nonce,"f//499k954d6OL34oL9FSTvy64sA");
res = stun_check_message_integrity_str(TURN_CREDENTIALS_LONG_TERM, buf, sizeof(reqltc) - 1, uname, realm,
upwd, shatype);
printf("RFC 5769 message structure, long-term credentials and integrity test result: ");
if (res > 0) {
printf("success\n");
} else if (res == 0) {
printf("failure on integrity check\n");
exit(-1);
} else {
printf("failure on message structure check\n");
exit(-1);
}
{ //encoding test
printf("RFC 5769 message encoding test result: ");
size_t len = 0;
u16bits message_type = STUN_METHOD_BINDING;
stun_tid tid;
u16bits *buf16 = (u16bits*)buf;
u32bits *buf32 = (u32bits*)buf;
memcpy(tid.tsx_id,"\x78\xad\x34\x33\xc6\xad\x72\xc0\x29\xda\x41\x2e",12);
stun_init_buffer_str(buf,&len);
message_type &= (u16bits)(0x3FFF);
buf16[0]=nswap16(message_type);
buf16[1]=0;
buf32[1]=nswap32(STUN_MAGIC_COOKIE);
stun_tid_message_cpy(buf, &tid);
stun_attr_add_integrity_by_user_str(buf, &len, uname, realm, upwd, nonce, shatype);
if(len != (sizeof(reqltc)-1)) {
printf("failure: length %d, must be %d\n",(int)len,(int)(sizeof(reqltc)-1));
exit(-1);
}
if(memcmp(buf,reqltc,len)) {
printf("failure: wrong message content\n");
{
int lines = 29;
int line = 0;
int col = 0;
int cols = 4;
for(line = 0;line<lines;line++) {
for(col = 0; col<cols; col++) {
u08bits c = buf[line*4+col];
printf(" %2x",(int)c);
}
printf("\n");
}
}
exit(-1);
}
printf("success\n");
}
//Negative test:
buf[32] = 10;
res = stun_check_message_integrity_str(TURN_CREDENTIALS_LONG_TERM, buf, sizeof(reqltc) - 1, uname, realm,
upwd, shatype);
printf("RFC 5769 NEGATIVE long-term credentials test result: ");
if (res == 0) {
printf("success\n");
} else {
printf("failure on NEGATIVE long-term credentials check\n");
exit(-1);
}
}
{
const unsigned char respv4[] = "\x01\x01\x00\x3c"
"\x21\x12\xa4\x42"
"\xb7\xe7\xa7\x01\xbc\x34\xd6\x86\xfa\x87\xdf\xae"
"\x80\x22\x00\x0b"
"\x74\x65\x73\x74\x20\x76\x65\x63\x74\x6f\x72\x20"
"\x00\x20\x00\x08"
"\x00\x01\xa1\x47\xe1\x12\xa6\x43"
"\x00\x08\x00\x14"
"\x2b\x91\xf5\x99\xfd\x9e\x90\xc3\x8c\x74\x89\xf9"
"\x2a\xf9\xba\x53\xf0\x6b\xe7\xd7"
"\x80\x28\x00\x04"
"\xc0\x7d\x4c\x96";
u08bits buf[sizeof(respv4)];
memcpy(buf, respv4, sizeof(respv4));
{//fingerprintfs etc
res = stun_is_command_message_full_check_str(buf, sizeof(respv4) - 1, 1, NULL);
printf("RFC 5769 message fingerprint test(1) result: ");
if (res) {
printf("success\n");
} else if (res == 0) {
printf("failure on fingerprint(1) check\n");
exit(-1);
}
}
{//short-term credentials
u08bits uname[33];
u08bits realm[33];
u08bits upwd[33];
strcpy((char*) upwd, "VOkJxbRl1RmTxUk/WvJxBt");
res = stun_check_message_integrity_str(TURN_CREDENTIALS_SHORT_TERM, buf, sizeof(respv4) - 1, uname, realm, upwd, shatype);
printf("RFC 5769 IPv4 response short-term credentials and integrity test result: ");
if (res > 0) {
printf("success\n");
} else if (res == 0) {
printf("failure on integrity check\n");
exit(-1);
} else {
printf("failure on message structure check\n");
exit(-1);
}
}
{//negative fingerprint
buf[27] = 23;
res = stun_is_command_message_full_check_str(buf, sizeof(respv4) - 1, 1, NULL);
printf("RFC 5769 NEGATIVE fingerprint test(1) result: ");
if (!res) {
printf("success\n");
} else if (res == 0) {
printf("failure on NEGATIVE fingerprint check\n");
exit(-1);
}
}
{//IPv4 addr
ioa_addr addr4;
ioa_addr addr4_test;
printf("RFC 5769 IPv4 encoding result: ");
res = stun_attr_get_first_addr_str(buf, sizeof(respv4)-1, STUN_ATTRIBUTE_XOR_MAPPED_ADDRESS, &addr4, NULL);
if(res < 0) {
printf("failure on message structure check\n");
exit(-1);
}
make_ioa_addr((const u08bits*)"192.0.2.1", 32853, &addr4_test);
if(addr_eq(&addr4,&addr4_test)) {
printf("success\n");
} else {
printf("failure on IPv4 deconding check\n");
exit(-1);
}
}
}
{
const unsigned char respv6[] = "\x01\x01\x00\x48"
"\x21\x12\xa4\x42"
"\xb7\xe7\xa7\x01\xbc\x34\xd6\x86\xfa\x87\xdf\xae"
"\x80\x22\x00\x0b"
"\x74\x65\x73\x74\x20\x76\x65\x63\x74\x6f\x72\x20"
"\x00\x20\x00\x14"
"\x00\x02\xa1\x47"
"\x01\x13\xa9\xfa\xa5\xd3\xf1\x79"
"\xbc\x25\xf4\xb5\xbe\xd2\xb9\xd9"
"\x00\x08\x00\x14"
"\xa3\x82\x95\x4e\x4b\xe6\x7b\xf1\x17\x84\xc9\x7c"
"\x82\x92\xc2\x75\xbf\xe3\xed\x41"
"\x80\x28\x00\x04"
"\xc8\xfb\x0b\x4c";
u08bits buf[sizeof(respv6)];
{ //decoding test
memcpy(buf, respv6, sizeof(respv6));
res = stun_is_command_message_full_check_str(buf, sizeof(respv6) - 1, 1, NULL);
printf("RFC 5769 message fingerprint test(2) result: ");
if (res) {
printf("success\n");
} else if (res == 0) {
printf("failure on fingerprint(2) check\n");
exit(-1);
}
}
{//short-term credentials test
u08bits uname[33];
u08bits realm[33];
u08bits upwd[33];
strcpy((char*) upwd, "VOkJxbRl1RmTxUk/WvJxBt");
res = stun_check_message_integrity_str(TURN_CREDENTIALS_SHORT_TERM, buf, sizeof(respv6) - 1, uname, realm, upwd, shatype);
printf("RFC 5769 IPv6 response short-term credentials and integrity test result: ");
if (res > 0) {
printf("success\n");
} else if (res == 0) {
printf("failure on integrity check\n");
exit(-1);
} else {
printf("failure on message structure check\n");
exit(-1);
}
}
{//negative decoding test
buf[27] = 23;
res = stun_is_command_message_full_check_str(buf, sizeof(respv6) - 1, 1, NULL);
printf("RFC 5769 NEGATIVE fingerprint test(2) result: ");
if (!res) {
printf("success\n");
} else if (res == 0) {
printf("failure on NEGATIVE fingerprint check\n");
exit(-1);
}
}
{//IPv6 deconding test
ioa_addr addr6;
ioa_addr addr6_test;
printf("RFC 5769 IPv6 encoding result: ");
res = stun_attr_get_first_addr_str(buf, sizeof(respv6) - 1,
STUN_ATTRIBUTE_XOR_MAPPED_ADDRESS, &addr6, NULL);
if (res < 0) {
printf("failure on message structure check\n");
exit(-1);
}
make_ioa_addr((const u08bits*) "2001:db8:1234:5678:11:2233:4455:6677", 32853, &addr6_test);
if (addr_eq(&addr6, &addr6_test)) {
printf("success\n");
} else {
printf("failure on IPv6 deconding check\n");
exit(-1);
}
}
}
{
if(check_oauth()<0)
exit(-1);
}
return 0;
}
