void AstEnumDeclaration::Unparse(Ostream& os, LexStream* lex_stream) { unsigned i; if (debug_unparse) os << "/*AstEnumDeclaration:#" << id << "*/"; if (lex_stream -> IsDeprecated(LeftToken())) os << "/**@deprecated*/ "; if (modifiers_opt) modifiers_opt -> Unparse(os, lex_stream); os << lex_stream -> NameString(enum_token) << ' ' << lex_stream -> NameString(class_body -> identifier_token) << ' '; if (NumInterfaces()) { os << "extends "; Interface(0) -> Unparse(os, lex_stream); for (i = 1; i < NumInterfaces(); i++) { os << ", "; Interface(i) -> Unparse(os, lex_stream); } } os << '{' << endl; for (i = 0; i < NumEnumConstants(); i++) { EnumConstant(i) -> Unparse(os, lex_stream); os << ',' << endl; } class_body -> Unparse(os, lex_stream, true); if (debug_unparse) os << "/*:AstEnumDeclaration#" << id << "*/"; }
bool PAP::SendRequest() { TRACE("PAP: SendRequest() state=%d\n", State()); --fRequestCounter; fNextTimeout = system_time() + kPAPTimeout; net_buffer *packet = gBufferModule->create(256); if (!packet) return false; ppp_lcp_packet *request; gBufferModule->append_size(packet, 1492, (void **)&request); const char *username = Interface().Username(), *password = Interface().Password(); uint16 packcketLenth = 6 + strlen(username) + strlen(password); // 6 : lcp header 4 byte + username length 1 byte + password length 1 byte request->code = PPP_CONFIGURE_REQUEST; request->id = fRequestID = NextID(); request->length = htons(packcketLenth); uint8 *data = request->data; data[0] = strlen(username); memcpy(data + 1, username, strlen(username)); data[1 + data[0]] = strlen(password); memcpy(data + 2 + data[0], password, strlen(password)); gBufferModule->trim(packet, packcketLenth); return Interface().Send(packet, PAP_PROTOCOL) == B_OK; }
void PAP::RNEvent(net_buffer *packet) { TRACE("PAP: RNEvent() state=%d\n", State()); NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet); if (bufferheader.Status() != B_OK) return; ppp_lcp_packet &lcp_hdr = bufferheader.Data(); if (fRequestID != lcp_hdr.id) { // this packet is not a reply to our request // TODO: log this event gBufferModule->free(packet); return; } switch (State()) { case REQ_SENT: NewState(INITIAL); Interface().StateMachine().LocalAuthenticationDenied( Interface().Username()); UpFailedEvent(); break; default: ; } gBufferModule->free(packet); }
void AstInterfaceDeclaration::Unparse(Ostream& os, LexStream* lex_stream) { if (debug_unparse) os << "/*AstInterfaceDeclaration:#" << id << "*/"; if (lex_stream -> IsDeprecated(LeftToken())) os << "/**@deprecated*/ "; if (modifiers_opt) modifiers_opt -> Unparse(os, lex_stream); os << lex_stream -> NameString(interface_token) << ' ' << lex_stream -> NameString(class_body -> identifier_token) << ' '; if (type_parameters_opt) type_parameters_opt -> Unparse(os, lex_stream); if (NumInterfaces()) { os << "extends "; Interface(0) -> Unparse(os, lex_stream); for (unsigned i = 1; i < NumInterfaces(); i++) { os << ", "; Interface(i) -> Unparse(os, lex_stream); } } class_body -> Unparse(os, lex_stream); if (debug_unparse) os << "/*:AstInterfaceDeclaration#" << id << "*/"; }
//! This method is never used. status_t KPPPDevice::Receive(struct mbuf *packet, uint16 protocolNumber) { // let the interface handle the packet if (protocolNumber == 0) return Interface().ReceiveFromDevice(packet); else return Interface().Receive(packet, protocolNumber); }
void Interface(void) { string input; cout << "> "; cin >> input; if ((input.compare("h") == 0) || (input.compare("help") == 0)) { cout << "Available commands:" << endl; cout << "\t[h]elp " << "\t\tHelp" << endl; cout << "\t[f]ermat" << "\t\tChoose Fermat PrimalityTest" << endl; cout << "\t[t]rial " << "\t\tChoose Trial Division PrimalityTest" << endl; cout << "\t[q]uit " << "\t\tQuit" << endl; cout << "\t<number>" << "\t\tThe number in test" << endl; Interface(); } else if ((input.compare("f") == 0) || (input.compare("fermat") == 0)) { ChangePrimalityTest(fermat); Interface(); } else if ((input.compare("t") == 0) || (input.compare("trial") == 0)) { ChangePrimalityTest(trial); Interface(); } else if ((input.compare("q") == 0) || (input.compare("quit") == 0)) { exit(0); } else { bool isnumber = true; for (int i=0; i<input.length(); i++) { if (!isdigit(input[i])) { cout << "Unknown command. Try h for help" << endl; isnumber = false; break; } } if (isnumber) { if (ptCurrent->IsPrime(input)) cout << input << " is a prime" << endl; else cout << input << " is not a prime" << endl; } Interface(); } }
void _KPPPMRUHandler::Reset() { if (Interface().Device()) { fLocalMRU = Interface().Device()->MTU() - 2; Interface().SetMRU(fLocalMRU); } else { Interface().SetMRU(1500); fLocalMRU = 1500; } }
status_t _KPPPMRUHandler::AddToRequest(KPPPConfigurePacket& request) { if (!Interface().Device() || Interface().MRU() == 1500) return B_OK; // add MRU request mru_item item; item.type = kMRUType; item.length = 4; item.MRU = htons(fLocalMRU); return request.AddItem((ppp_configure_item*) &item) ? B_OK : B_ERROR; }
Interface Context::addInterface(const std::string &name) { const int r = asDetails.asEngine->RegisterInterface(name.c_str()); assert(r >= 0); return Interface(this, name); }
int Run(int argc, char** argv) { try { bool showHelp = false; ArgParserPtr arg = ArgParser::Create(); arg->AddSwitch('h', "help", "Show help.", [&](){ showHelp = true; }); std::vector<std::string> rest = arg->Parse(argc, argv); if(showHelp) { std::cout << "Usage: " << argv[0] << " [OPTION]" << std::endl; std::cout << arg->GetHelp(); return 0; } Interface(); } catch (std::runtime_error ex){ FlogF(ex.what()); return 1; } catch (std::exception ex) { FlogF(ex.what()); return 1; } return 0; }
int Interface(){ printf("|+++------------------------------------------------------------------+++|\n"); printf("|+++------------------------------------------------------------------+++|\n"); printf("|+++---------------WELCOME TO THE CLOUD STORAGE SYSTEM----------------+++|\n"); printf("|+++------------------------------------------------------------------+++|\n"); printf("|+++------------------------------------------------------------------+++|\n"); printf("| |\n"); printf("| |\n"); printf("| |\n"); printf("| PRESS 1 : >>>>>> | SIGNUP | |\n"); printf("| PRESS 2 : >>>>>> | SIGNIN | |\n"); printf("| PRESS 3 : >>>>>> | TO KNOW ABOUT THE SYSTEM | |\n"); printf("| PRESS 4 : >>>>>> | TO QUIT | |\n"); printf("| |\n"); printf("| |\n"); printf("| |\n"); printf("|+++------------------------------------------------------------------+++|\n"); printf("|+++------------------------------------------------------------------+++|\n"); int in; scanf("%d",&in); if(in==4) exit(0); if(in==1 || in==2 || in==3) return in; else { printf("\n ENTER THE VALID NUMBER \n\n"); Interface(); } }
//! Reports that device failed going up. May only be called after Up() was called. void KPPPDevice::UpFailedEvent() { fConnectionPhase = PPP_DOWN_PHASE; Interface().StateMachine().UpFailedEvent(); }
/*! \brief Report that device is going down. Called by Down(). \return - \c true: You are allowed to disconnect. - \c false: You must not disconnect! */ bool KPPPDevice::DownStarted() { fConnectionPhase = PPP_TERMINATION_PHASE; return Interface().StateMachine().TLFNotify(); }
/*! \brief Report that device is going up. Called by Up(). \n From now on, the connection attempt can may be aborted by calling Down(). \return - \c true: You are allowed to connect. - \c false: You should abort immediately. Down() will \e not be called! */ bool KPPPDevice::UpStarted() { fConnectionPhase = PPP_ESTABLISHMENT_PHASE; return Interface().StateMachine().TLSNotify(); }
bool PAP::Down() { TRACE("PAP: Down() state=%d\n", State()); switch (Interface().Phase()) { case PPP_DOWN_PHASE: // interface finished terminating case PPP_ESTABLISHED_PHASE: // terminate this NCP individually (block until we finished terminating) NewState(INITIAL); DownEvent(); break; /* case PPP_TERMINATION_PHASE: // interface is terminating break; case PPP_ESTABLISHMENT_PHASE: // interface is reconfiguring break; */ default: ; } return true; }
//! Reports that device went up. May only be called after Up() was called. void KPPPDevice::UpEvent() { fConnectionPhase = PPP_ESTABLISHED_PHASE; Interface().StateMachine().UpEvent(); }
void TratamentoComandos(Nave & nave, Consola & consola, bool & jogoActivo) { string entrada; int pos, idSala; while (true) { Interface(consola, nave); if (jogoActivo) { consola.gotoxy(40, 40); cout << "Distancia percorrida: " << nave.getDistanciaPercorrida(); consola.gotoxy(40, 42); cout << "TURNO: " << n_turnos << endl; nave.mostraIntegridadeSalas(nave, consola); nave.mostraOxigenioSalas(nave, consola); nave.mostraEfeitosAmbientaisSalas(nave, consola); } //consola.gotoxy(1, 45); nave.mostraTripulantes(consola); nave.mostraInimigos(consola); nave.mostraXenomorfos(consola); consola.gotoxy(2, 57); cout << "Comando > "; getline(cin, entrada); if (entrada == "fim") break; istringstream iss(entrada); //Verifica se é comando de mover a tripulação if ((entrada.length() == 2) && (entrada[1] - 48 >= 0 && entrada[1] - 48 <= 9)) { pos = nave.pesquisaTripulante((char)toupper(entrada[0])); if (pos >= 0) { idSala = entrada[1] - 48; if (idSala >= 0 && idSala <= 12) nave.atribuiSalaTripulante(pos, idSala - 1); } } else if ((entrada.length() == 3) && (entrada[2] - 48 >= 0 && entrada[2] - 48 <= 9)) { pos = nave.pesquisaTripulante((char)toupper(entrada[0])); if (pos >= 0) { idSala = (entrada[1] - 48) * 10 + (entrada[2] - 48); if (idSala >= 0 && idSala <= 12) nave.atribuiSalaTripulante(pos, idSala - 1); } } else { } } }
void Interfaces::Load() { struct ifaddrs* ifaddr, *ifa; if (getifaddrs(&ifaddr) == -1) return throw NetworkSystemError(errno); std::shared_ptr<struct ifaddrs> ifaddrGuard(ifaddr, freeifaddrs); IPAddress ip; for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) { if (!ifa->ifa_addr) continue; if (ifa->ifa_addr->sa_family == AF_INET) { struct sockaddr_in* addr4 = reinterpret_cast<struct sockaddr_in*>(ifa->ifa_addr); ip = IPAddress(&addr4->sin_addr, sizeof(addr4->sin_addr)); } else if (ifa->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6* addr6 = reinterpret_cast<struct sockaddr_in6*>(ifa->ifa_addr); ip = IPAddress(&addr6->sin6_addr, sizeof(addr6->sin6_addr)); } else continue; std::string name = ifa->ifa_name; std::map<std::string, Interface>::iterator it = interfaces.insert(std::make_pair(name, Interface(name))).first; it->second.addresses.emplace_back(ip); } }
//! Reports that device went down. This may be called to indicate connection loss. void KPPPDevice::DownEvent() { fConnectionPhase = PPP_DOWN_PHASE; Interface().StateMachine().DownEvent(); }
InterfacesBase::Interface &InterfacesBase::get(int index) { int len = interfaces.length(); for (int i=0; i<len; i++) { if (interfaces[i].index() == index) return interfaces[i]; } return Interface("", -1); }
int main(int argc, char *argv[]) { ChangePrimalityTest(fermat); Interface(); return 0; }
status_t _KPPPMRUHandler::ParseRequest(const KPPPConfigurePacket& request, int32 index, KPPPConfigurePacket& nak, KPPPConfigurePacket& reject) { if (index == reject.CountItems()) return B_OK; return ParseRequestedItem((mru_item*) request.ItemAt(index), Interface()); return B_OK; }
void GUI_Manager::mt_Add_Interface(const GameStateType& state, GUI_Interface* inter) { auto l_state = m_interfaces.find(state); if (l_state == m_interfaces.end()) { l_state = m_interfaces.emplace(state, Interface()).first; } l_state->second.emplace(inter->mt_Get_Id(), inter).first->second->mt_Set_Environment(m_environment); }
/*! \brief Enables or disables this protocol. A disabled protocol is ignored and Up() is not called! */ void KPPPProtocol::SetEnabled(bool enabled) { fEnabled = enabled; if (!enabled) { if (IsUp() || IsGoingUp()) Down(); } else if (!IsUp() && !IsGoingUp() && IsUpRequested() && Interface().IsUp()) Up(); }
int main() { glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluOrtho2D(-15.5,15.5,-15.5,17.5); Interface inf = Interface(); inf.maine(); return EXIT_SUCCESS; }
void PAP::NewState(pap_state next) { TRACE("PAP: NewState(%d) state=%d\n", next, State()); // state changes if (State() == INITIAL && next != State()) { if (Side() == PPP_LOCAL_SIDE) Interface().StateMachine().LocalAuthenticationRequested(); else if (Side() == PPP_PEER_SIDE) Interface().StateMachine().PeerAuthenticationRequested(); UpStarted(); } else if (State() == ACCEPTED && next != State()) DownStarted(); // maybe we do not need the timer anymore if (next == INITIAL || next == ACCEPTED) fNextTimeout = 0; fState = next; }
void PAP::RREvent(net_buffer *packet) { TRACE("PAP: RREvent() state=%d\n", State()); NetBufferHeaderReader<ppp_lcp_packet> bufferheader(packet); if (bufferheader.Status() != B_OK) return; ppp_lcp_packet &request = bufferheader.Data(); int32 length = ntohs(request.length); uint8 *data = request.data; uint8 *userLength = data; uint8 *passwordLength = data + 1 + data[0]; // make sure the length values are all okay if (6 + *userLength + *passwordLength > length) { gBufferModule->free(packet); return; } char *peerUsername = (char*) userLength + 1, *peerPassword = (char*) passwordLength + 1; const char *username = Interface().Username(), *password = Interface().Password(); if (*userLength == strlen(username) && *passwordLength == strlen(password) && !strncmp(peerUsername, username, *userLength) && !strncmp(peerPassword, password, *passwordLength)) { NewState(ACCEPTED); Interface().StateMachine().PeerAuthenticationAccepted(username); UpEvent(); SendAck(packet); } else { NewState(INITIAL); Interface().StateMachine().PeerAuthenticationDenied(username); UpFailedEvent(); SendNak(packet); } }
INT WINAPI WinMain(HINSTANCE hi, HINSTANCE hpi, LPSTR lpcmd, INT ncs) { INT argc; LPWSTR *argv = CommandLineToArgvW(GetCommandLine(), &argc); if (argc == 2) { Borderless(argv[1]); } else { Interface(hi, hpi, ncs); } LocalFree(argv); return 0; }
void PAP::TOBadEvent() { TRACE("PAP: TOBadEvent() state=%d\n", State()); switch (State()) { case REQ_SENT: case WAITING_FOR_REQ: NewState(INITIAL); if (State() == REQ_SENT) Interface().StateMachine().LocalAuthenticationDenied( Interface().Username()); else Interface().StateMachine().PeerAuthenticationDenied( Interface().Username()); UpFailedEvent(); break; default: ; } }
status_t _KPPPMRUHandler::ParseAck(const KPPPConfigurePacket& ack) { uint16 MRU = 1500; mru_item *item = (mru_item*) ack.ItemWithType(kMRUType); if (item) MRU = ntohs(item->MRU); if (MRU < Interface().MRU()) fLocalMRU = MRU; return B_OK; }