/** * Check if X509Cert is signed by trusted issuer * @return 0 or openssl error_code. Get human readable cause with X509_verify_cert_error_string(code) * @throw IOException if error */ int digidoc::X509Cert::verify() const throw(IOException) { X509_STORE_CTX *csc = X509_STORE_CTX_new(); X509_STORE_CTX_scope csct(&csc); if (!csc) THROW_IOEXCEPTION("Failed to create X509_STORE_CTX %s",ERR_reason_error_string(ERR_get_error())); X509_STORE *store = digidoc::X509CertStore::getInstance()->getCertStore(); X509* x = getX509(); X509_scope xt(&x); if(!X509_STORE_CTX_init(csc, store, x, NULL)) THROW_IOEXCEPTION("Failed to init X509_STORE_CTX %s",ERR_reason_error_string(ERR_get_error())); int ok = X509_verify_cert(csc); if(!ok) { int err = X509_STORE_CTX_get_error(csc); X509Cert cause(X509_STORE_CTX_get_current_cert (csc)); std::ostringstream s; s << "Unable to verify " << cause.getSubject(); s << ". Cause: " << X509_verify_cert_error_string(err); switch(err) { case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: { IOException e(__FILE__, __LINE__, s.str()); e.setCode( Exception::CertificateIssuerMissing ); throw e; break; } default: THROW_IOEXCEPTION(s.str().c_str()); break; } } return ok; }
void cause_rethrow() { try { cause(); } catch( C const &r ) { if( r.s <= 0 ) fail(__LINE__); throw; } }
void cause_throw_anew() { try { cause(); } catch( C const &r ) { if( r.s <= 0 ) fail(__LINE__); throw r; } }
int main (int argc, char*argv[]) { static int n, /* # de nodos */ token, event, r, i; static char fa_name[5]; if (argc != 2) { printf("Uso incorreto. Sintaxe: '%s <# de nodos>'\n",argv[0]); exit(1); } n=atoi(argv[1]); smpl(0,"um exemplo de simulacao"); reset(); stream(1); /* INICIALIZACAO */ nodo = (tnodo*) malloc(sizeof(tnodo)*n); for (i=0;i<n;i++) { memset(fa_name, 0, 5); sprintf(fa_name,"%d",i); nodo[i].id = facility(fa_name,1); /* Aqui inicializa as variáveis locais */ } /* escalonamento ds eventos */ for (i=0; i<n; i++) schedule(test,30.0,i); schedule(fault,50.0,2); schedule(repair,80.0,2); while(time() < 100) { cause(&event,&token); switch(event) { case test: if(status(nodo[token].id) != 0) break; printf("O nodo %d vai estar no tempo %5.1f\n",token,time()); schedule(test,30.0,token); break; case fault: r=request(nodo[token].id,token,0); if(r!=0) { printf("Nao foi possivel falhar o nodo %d\n",token); exit(1); } printf("O nodo %d falhou no tempo %5.1f\n", token, time()); break; case repair: printf("O nodo %d se recuperou no tempo %5.1f\n", token, time()); release(nodo[token].id,token); schedule(test,30.0,token); break; } } }
bool bdoc::X509Cert::verify(X509_STORE* aStore, struct tm* tm) const { if (aStore == NULL) { THROW_STACK_EXCEPTION("Invalid argument to verify"); } X509_STORE* store = aStore; X509_STORE** ppStore = NULL; X509_STORE_scope xst(ppStore); X509_STORE_CTX *csc = X509_STORE_CTX_new(); X509_STORE_CTX_scope csct(&csc); if (csc == NULL) { THROW_STACK_EXCEPTION("Failed to create X509_STORE_CTX %s",ERR_reason_error_string(ERR_get_error())); } X509* x = getX509(); X509_scope xt(&x); if (!X509_STORE_CTX_init(csc, store, x, NULL)) { THROW_STACK_EXCEPTION("Failed to init X509_STORE_CTX %s",ERR_reason_error_string(ERR_get_error())); } if (tm != NULL) { time_t t = timegm(tm); if (t == -1) { THROW_STACK_EXCEPTION("Given time cannot be represented as calendar time"); } X509_VERIFY_PARAM *param = X509_STORE_CTX_get0_param(csc); if (param == NULL) { THROW_STACK_EXCEPTION("Failed to retrieve X509_STORE_CTX verification parameters %s", ERR_reason_error_string(ERR_get_error())); } X509_VERIFY_PARAM_set_time(param, t); } int ok = X509_verify_cert(csc); if (ok != 1) { int err = X509_STORE_CTX_get_error(csc); X509Cert cause(X509_STORE_CTX_get_current_cert (csc)); std::ostringstream s; s << "Unable to verify " << cause.getSubject(); s << ". Cause: " << X509_verify_cert_error_string(err); switch (err) { case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: { THROW_STACK_EXCEPTION("Certificate issuer missing: %s", s.str().c_str()); } default: THROW_STACK_EXCEPTION(s.str().c_str()); break; } } return (ok == 1); }
void Dss1CallForGate::WaitAnswerTimeout(iCore::MsgTimer *pT) { if(m_isConnected) return; if(m_log->LogActive(m_infoTag)) { *m_log << m_infoTag << "Wait answer timer expired." << iLogW::EndRecord; } boost::shared_ptr<const ISDN::DssCause> cause(Cause(ISDN::IeConstants::NoUserResponding)); ClearUserCallRef(cause); ReleaseDss1(cause); }
void Dss1CallForGate::Release(const IDss1CallEvents *id, int rejectCode) { ESS_ASSERT(m_userCall.IsEqualIntf(id)); if(!m_userCall.IsEmpty()) { SetupCallRecord(); m_userCall.Clear(); } boost::shared_ptr<const ISDN::DssCause> cause(Cause(rejectCode)); if(m_log->LogActive(m_infoTag)) { *m_log << m_infoTag << "Disconnent from user. " << cause->ToString() << iLogW::EndRecord; } ReleaseDss1(cause); }
void Dss1CallForGate::ChannelDeleted(iCmpExt::CmpChannelId channelId, const std::string &desc) { ESS_ASSERT(GetCmpChannelId() == channelId); m_cmpChannel.reset(); if(m_log->LogActive(m_infoTag)) { *m_log << m_infoTag << "Channel error."; if(!desc.empty()) *m_log << " " << desc; *m_log << iLogW::EndRecord; } boost::shared_ptr<const ISDN::DssCause> cause(Cause(ISDN::IeConstants::TemporaryFailure)); ClearUserCallRef(cause); ReleaseDss1(cause); }
int main(int argc, char *argv[]){ static int N, /* Numero de nodos */ token, event, teste, r, i; static char fa_name[5]; /* Facility Name */ char *fail_code[2] = {"Sem falha", "Falho"}; if(argc != 2){ printf("USO: %s num_nodos\n", argv[0]); exit(1); } N = atoi(argv[1]); smpl(0, "Um Exemplo"); reset(); stream(1); /* Inicializacao */ nodo = (Tnodo*) malloc(sizeof(Tnodo)*N); for(i = 0; i < N; i++){ memset(fa_name, "\0", 5); sprintf(fa_name, "%d", i); nodo[i].id = facility(fa_name, 1); nodo[i].stats = -1; /* Aqui inicializa as variaveis locais */ } /* Escalonamento de eventos */ for(i=0; i<N; i++){ schedule(test, 30.0, i); } schedule(fault, 50.0, 2); /* O nodo 2 vai falhar em 50.0 */ schedule(fault, 50.0, 3); schedule(fault, 50.0, 4); schedule(repair, 100.0, 2); while(time() < 200){ cause(&event, &token); switch(event){ case test: if(status(nodo[token].id) != 0) break; teste = status(nodo[(token+1)%N].id); i = 1; while(teste){ teste = status(nodo[(token+i)%N].id); if(!teste == 0){ nodo[token].stats = (token+i)%N; i++; } } printf("%5.1f - O nodo %d testou o nodo %d. Resultado: %s\n", time(), token, (token+i)%N, fail_code[teste], nodo[token].stats); schedule(test, 30.0, token); break; case fault: r = request(nodo[token].id, token, 0); if(r != 0){ puts("Nao foi possivel falhar o nodo\n"); exit(1); } printf("%5.1f - O nodo %d falhou\n", time(), token); break; case repair: printf("%5.1f - O nodo %d recuperou\n", time(), token); release(nodo[token].id, token); schedule(test, 30.0, token); break; } } return 0; }
/* Program body */ int main(int argc, char *argv[]) { static int N; static int token; static int event; static int sender; static int timestamp; static int r; static int i; static int delay; static char fa_name[5]; int scheduled_events = 0; if (argc < 2) { show_usage(); exit(1); } // Number of nodes N = argc-1; // Sets up SMPL simulation smpl(0, "mutual exclusion"); reset(); stream(1); // 1 execution thread // Node intialization nodes = (Node*) malloc(N*sizeof(Node)); int times[N]; for (i=0; i<N; i++) { memset (fa_name, '\0', 5); sprintf(fa_name, "%d", i); nodes[i].id = facility(fa_name, 1); nodes[i].running = false; nodes[i].clock = 0; nodes[i].pending = (bool *) malloc(N*sizeof(bool)); memset (nodes[i].pending, false, N*sizeof(bool)); nodes[i].waiting_reply = 0; times[i] = atoi(argv[i+1]); // Timestamp -1 means that the node has no active request nodes[i].timestamp = -1; } // Schedules the critical region requests for (i=0; i<N; i++) { schedule (REQUEST, times[i], i, i, 0); scheduled_events++; } printf("=============================================================================\n"); printf(" Ricart-Agrawala mutual exclusion algorithm \n"); printf(" Renan Greca - Distributed Systems, May 2016 \n"); printf("=============================================================================\n"); // The program keeps running while there are still events scheduled while (scheduled_events > 0) { printf("-----\n"); cause(&event, &token, &sender, ×tamp); switch(event) { case REQUEST: // REQUEST critical region access to other nodes scheduled_events--; nodes[token].clock++; printf("(%d, %d) Requested C.R. \n", token, nodes[token].clock); // Stores timestamp of request for priority reference nodes[token].timestamp = nodes[token].clock; // Sends requests to all other nodes for (i=0; i<N; i++) { if (i==token) { continue; } delay = rand_int(0, MAX_MESSAGE_DELAY); // Sends REQUEST message to node i with a random delay schedule (RECEIVE_REQUEST, delay, i, token, nodes[token].clock); scheduled_events++; nodes[token].waiting_reply++; } break; case RECEIVE_REQUEST: // Receive and handle a REQUEST scheduled_events--; // Updates logical clock nodes[token].clock = (nodes[token].clock > timestamp ? nodes[token].clock : timestamp)+1; printf("(%d, %d) Received request from %d\n", token, nodes[token].clock, sender); // Checks whether the sender node has priority over the receiver if (priority(sender, token, timestamp, nodes[token].timestamp) && !nodes[token].running) { // If the sender has priority, send a REPLY delay = rand_int(0, MAX_MESSAGE_DELAY); printf("(%d, %d) Sending reply to %d\n", token, nodes[token].clock, sender); schedule(RECEIVE_REPLY, delay, sender, token, nodes[token].clock); scheduled_events++; } else { // Else, store it in the pending array printf("(%d, %d) Adding %d to pending array\n", token, nodes[token].clock, sender); nodes[token].pending[sender] = true; } break; case RECEIVE_REPLY: // Receive and handle a REPLY scheduled_events--; // Updates logical clock nodes[token].clock = (nodes[token].clock > timestamp ? nodes[token].clock : timestamp)+1; printf("(%d, %d) Received reply from %d\n", token, nodes[token].clock, sender); nodes[token].waiting_reply--; // If node received all replies, it enters the critical region if (nodes[token].waiting_reply == 0) { printf("(%d, %d) Entered the critical region.\n", token, nodes[token].clock); schedule (RELEASE, RUNNING_INTERVAL, token, token, nodes[token].clock); scheduled_events++; nodes[token].running = true; } break; case RELEASE: // Release the critical region and alert other nodes scheduled_events--; nodes[token].clock++; printf("(%d, %d) Left the critical region.\n", token, nodes[token].clock); // Clear the information of the previous request nodes[token].running = false; nodes[token].timestamp = -1; // Send all pending REPLIES for (i=0; i<N; i++) { if (nodes[token].pending[i]) { delay = rand_int(0, MAX_MESSAGE_DELAY); printf("(%d, %d) Sending reply to %d\n", token, nodes[token].clock, i); schedule(RECEIVE_REPLY, delay, i, token, nodes[token].clock); scheduled_events++; nodes[token].pending[i] = false; } } break; } } }
/* Program body */ int main(int argc, char *argv[]) { static int N; // Number of nodes static int token; static int event; static int r; static int i; static char fa_name[5]; if (argc != 2) { puts("Uso correto: tempo [num-nodos]"); exit(1); } N = atoi(argv[1]); smpl(0, "programa tempo"); reset(); stream(1); // 1 execution thread // Node intialization nodes = (Node*) malloc(N*sizeof(Node)); for (i=0; i<N; i++) { memset (fa_name, '\0', 5); sprintf(fa_name, "%d", i); nodes[i].id = facility(fa_name, 1); } for (i=0; i<N; i++) { schedule (TEST, 30.0, i); } schedule (FAULT, 31.0, 2); schedule (REPAIR, 61.0, 2); while (time() < 100.0) { cause(&event, &token); switch(event) { case TEST: if(status(nodes[token].id != 0)) { break; } printf("Sou o nodo %d, vou testar no tempo %5.1f\n", token, time()); printf("\n"); schedule(TEST, 30.0, token); break; case FAULT: r = request(nodes[token].id, token, 0); if (r != 0) { puts("Não consegui falhar o nodo!"); exit(1); } printf("Sou o nodo %d, falhei no tempo %5.1f\n", token, time()); break; case REPAIR: release(nodes[token].id, token); printf("Sou o nodo %d, recuperei no tempo %5.1f\n", token, time()); schedule(TEST, 30.0, token); break; } } }
int main(int argc, char **argv) { const double sim_time = 200; ///< Total simulation time static int show_usage = 0; ///< Flag to indicate if it is necessary to show usage options static int pnum = 0; ///< Number of processes in the system int event, ///< Current event pid, ///< ID of the process executing the event num_requests = 0, ///< Total number of requests in the simulation (used as stop criterion) p0_time = 0, ///< Time at which process 0 will request the critical region p1_time = 0, ///< Time at which process 1 will request the critical region p2_time = 0; ///< Time at which process 2 will request the critical region struct timeval tp; queue_item recvd_msg; print_header(); if (argc < 3) { print_usage(argv[0]); exit(1); } // parse parameters int c; while (1) { static struct option long_options[] = { {"help", no_argument, &show_usage, 1}, {"nproc", required_argument, 0, 'n'}, {"rc0", required_argument, 0, 'p'}, {"rc1", required_argument, 0, 'q'}, {"rc2", required_argument, 0, 'r'}, {0, 0, 0, 0} }; /* getopt_long stores the option index here. */ int option_index = 0; c = getopt_long(argc, argv, "n:p:q:r:", long_options, &option_index); /* Detect the end of the options. */ if (c == -1) break; switch (c) { case 0: /* If this option set a flag, do nothing else now. */ if (long_options[option_index].flag != 0) break; printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case 'n': pnum = (int) strtol(optarg, NULL, 10); break; case 'p': p0_time = (int) strtol(optarg, NULL, 10); ++num_requests; break; case 'q': p1_time = (int) strtol(optarg, NULL, 10); ++num_requests; break; case 'r': p2_time = (int) strtol(optarg, NULL, 10); ++num_requests; break; case '?': /* getopt_long already printed an error message. */ break; default: abort(); } } if (show_usage) { print_usage(argv[0]); exit(0); } if (pnum < 2) { printf("Error: Invalid number of processes! Please, specify at least 2 processes using the --nproc option.\n\n"); print_usage(argv[0]); exit(1); } else if (pnum < 2 && p2_time != 0) { printf("Error: You have specified a time for process 2 (starting from 0) on a simulation with only 2 processes!\n\n"); print_usage(argv[0]); exit(1); } else if (p0_time == 0 && p1_time == 0 && p2_time == 0) { printf("You have not specified any critical region requests in your simulation!\n\n"); print_usage(argv[0]); exit(1); } // initialize PRNG gettimeofday(&tp, NULL); srand(tp.tv_sec + tp.tv_usec / 1000); seed(tp.tv_sec + tp.tv_usec / 1000, 1); smpl(0, "Ricart-Agrawala"); stream(1); process plist = init_processes(pnum); printf("-- BEGIN PARAMETERS --\n"); printf("Number of processes: %d\n", pnum); printf("Number of critical region requests: %d\n", num_requests); printf("Starting events:\n"); if (p0_time != 0) { printf(" - Process 0 will request the critical region at time %d\n", p0_time); schedule(EV_REQUEST, p0_time, 0); } if (p1_time != 0) { printf(" - Process 1 will request the critical region at time %d\n", p1_time); schedule(EV_REQUEST, p1_time, 1); } if (p2_time != 0) { printf(" - Process 2 will request the critical region at time %d\n", p2_time); schedule(EV_REQUEST, p2_time, 2); } printf("-- END PARAMETERS --\n\n"); printf("-- SIMULATION BEGIN --\n"); while(time() < sim_time) { cause(&event, &pid); switch(event) { case EV_REQUEST: printf("Process %d has executed a critical region REQUEST at time %g\n", pid, time()); plist[pid].state = ST_WANTED; // update pid's logical clock plist[pid].timestamp++; plist[pid].request_timestamp = plist[pid].timestamp; // broadcast REQUEST to all processes in the system broadcast(plist, pnum, pid); break; case EV_RECV: // remove next message to be received by pid recvd_msg = remove_max_pqueue(plist[pid].recvd_from); // synchronize pid's logical clock on receive before processing the message plist[pid].timestamp = (plist[pid].timestamp > recvd_msg->timestamp) ? plist[pid].timestamp : recvd_msg->timestamp; plist[pid].timestamp++; printf("Process %d received %s from %d at time %g\n", pid, (recvd_msg->type == MSG_REQUEST) ? "REQUEST" : "REPLY", recvd_msg->pid, time()); recv(plist, pnum, pid, recvd_msg->pid, recvd_msg->timestamp, recvd_msg->type); free(recvd_msg); break; case EV_RELEASE: printf("Process %d released the critical region at time %g\n", pid, time()); releasecr(plist, pnum, pid); num_requests--; break; } // no more requests to simulate, simulation ended if (num_requests == 0) break; } printf("-- SIMULATION END --\n"); destroy_processes(plist, pnum); return 0; }