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;
}
