int main() { Poll p; //create server instance cppspEmbedded::Server srv(&p,"/"); //per-request state machine struct handler: public HandlerBase { void process() { response->write("aaaaa"); //flush content and headers; when writeback is done, flushCB() is called response->finalize({&handler::flushCB,this}); } void flushCB(Response&) { cb(); } }; //attach a custom request router srv.attachHandler(makeHandler<handler>()); //bind, listen, and accept, passing received sockets to the server Socket s; s.bind("0.0.0.0","16971",AF_INET,SOCK_STREAM); s.listen(); srv.listen(s); //add socket to epoll, and run the event loop p.add(s); p.loop(); }
void main() { Poll x; x.createPoll(); x.selectRecipients(); x.savePoll(); /*dataHub x; vector<string> test; vector<string> newData; newData.push_back("AAAAAAAAAAAAAAAAAAAAAAAAAAhfbifbasfbaisbdiasdbhasohdasdjaskdA"); newData.push_back("BBBBBBBBBBBBBBBBBBBBBpoiasjdoadjnsaodasdasdasdasdaBBBBBB"); newData.push_back("CCCCCCCCCCCCCCCCCCCCaidjaodsajhodajsdisajdoaisjdasiodjaosidjaCCCCCCC"); test = x.getInstructorsList(); print(test); test = x.updateInstructorsList(newData); cout << endl; print(test);*/ //string cmd; //cout << "Enter a command" << endl; //cin >> cmd; //stop getchar(); }
int main(int argc, const char *argv[]) { Poll poll; poll.go(); return 0; }
Poll* Poll::prepare(int opts) { bool allowNonCallbacks = opts & ALOOPER_PREPARE_ALLOW_NON_CALLBACKS; Poll* poller = Poll::getForThread(); if (NULL == poller) { poller = new Poll(allowNonCallbacks); Poll::setForThread(poller); } if (poller->getAllowNonCallbacks() != allowNonCallbacks) { ALOGW("Poll already prepared for this thread with a different value for the " "ALOOPER_PREPARE_ALLOW_NON_CALLBACKS option."); } return poller; }
int main(int argc, char** argv) { Poll p; Socket s(AF_INET,SOCK_STREAM); s.bind(IPEndPoint(IPAddress("0.0.0.0"),16969)); s.listen(); s.repeatAccept([&p](Socket* s1) { p.add(*s1); new client(*s1); s1->release(); }); p.add(s); p.loop(); }
void Session::run(void) { try { Thread::setPriority(Concurrency::Scheduler::POLICY_RR, 1); } catch (...) { } sendReply(220, "DUNE FTP server ready."); Poll poll; poll.add(*m_sock); poll.add(*m_sock_data); while (!isStopping()) { if (m_timer.overflow()) break; try { if (!poll.poll(1.0)) continue; if (!poll.wasTriggered(*m_sock)) continue; int rv = m_sock->read(m_bfr, sizeof(m_bfr)); if (rv <= 0) break; for (int i = 0; i < rv; ++i) { if (m_parser.parse(m_bfr[i])) { handleCommand(m_parser.getCode(), m_parser.getParameters()); m_timer.reset(); } } } catch (...) { break; } } closeControlConnection(); }
Server(Poll* p, string root):DefaultServer(root),p(p), _responsePool(128) { updateTime(); t.setCallback({&Server::timerCB,this}); p->add(t); handleRequest.attach( { &Server::_defaultHandleRequest, this }); }
int main() { Poll p; Socket s; s.bind("0.0.0.0","7000",AF_INET,SOCK_STREAM); s.listen(); struct { Poll& p; void operator()(Socket* s) { cout << "assssssss" << endl; struct handler { Poll& p; StreamReader sr; RGC::Ref<Socket> s; void lineCB(const string& l) { cout << "got line: " << l << endl; struct header { int a; void* v; char pad[8192]; int x; }* h=(header*)l.data(); h->pad[h->a]=h->x; delete this; } handler(Poll& p, Socket& s): p(p),sr(s),s(s) { sr.readLine(StreamReader::Callback(&handler::lineCB,this)); } } *hdlr=new handler(p,*s); p.add(*s); s->release(); } } cb {p}; s.repeatAccept(&cb); p.add(s); p.loop(); }
iptsocks_connection(Poll& p, HANDLE h1) : p(p), s1(h1, AF_INET, SOCK_STREAM, 0), s2(AF_INET, SOCK_STREAM, 0), incremented(false) { try { j.from1to2= {&iptsocks_connection::from1to2,this}; j.from2to1= {&iptsocks_connection::from2to1,this}; j.s1 = &s1; j.s2 = &s2; p.add(s1); p.add(s2); sockaddr_in dstaddr; socklen_t dstlen = sizeof(dstaddr); if (getsockopt(h1, SOL_IP, SO_ORIGINAL_DST, (struct sockaddr *) &dstaddr, &dstlen) != 0) throw runtime_error( strerror(errno)); ep.setSockAddr((sockaddr*) &dstaddr); //IPEndPoint ep2(IPAddress(iptsocks_params.socks_host), iptsocks_params.socks_port); s2.connect(*socks_host_ep, Callback(&iptsocks_connection::cb_connect, this)); retain(); } catch (exception& ex) { } }
int main(int argc, char **argv) { int i = 0; parseArgs(argc, argv, [&](char* name, const std::function<char*()>& getvalue) { char* tmpv; if(name==NULL) { switch(i) { case 0: iptsocks_params.socks_host=getvalue(); break; case 1: iptsocks_params.socks_port=getvalue(); break; } i++; } else if(strcmp(name,"d")==0) { if((tmpv=getvalue())==NULL)throw logic_error("-d(dns_port) requires a value"); iptsocks_params.dns_port=atoi(tmpv); } else if(strcmp(name,"p")==0) { if((tmpv=getvalue())==NULL)throw logic_error("-p(tcp_port) requires a value"); iptsocks_params.tcp_port=atoi(tmpv); } else if(strcmp(name,"s")==0) { if((tmpv=getvalue())==NULL)throw logic_error("-s(mapping_start_address) requires a value"); iptsocks_params.start_addr=tmpv; } else if(strcmp(name,"e")==0) { if((tmpv=getvalue())==NULL)throw logic_error("-e(mapping_end_address) requires a value"); iptsocks_params.end_addr=tmpv; } else if(strcmp(name,"h")==0) { cout << "usage: " << argv[0] << " [-p tcp_port] [-d dns_port] [-s mapping_start_address] [-e mapping_end_address] [socks_host] [socks_port]" << endl; exit(0); } }); if (iptsocks_params.end_addr.length() == 0) { iptsocks_params.end_addr = (IPAddress(iptsocks_params.start_addr.c_str()) + 65534).toStr(); } WARN(1, "params: socks_host=" << iptsocks_params.socks_host << "; socks_port=" << iptsocks_params.socks_port << "; tcp_port=" << iptsocks_params.tcp_port << "; dns_port=" << iptsocks_params.dns_port << "; mapping_start_address=" << iptsocks_params.start_addr << "; mapping_end_address=" << iptsocks_params.end_addr << ";"); pool= {IPAddress(iptsocks_params.start_addr.c_str()),IPAddress(iptsocks_params.end_addr.c_str())}; Poll p; auto vect = EndPoint::lookupHost(iptsocks_params.socks_host.c_str(), iptsocks_params.socks_port.c_str(), 0, SOCK_STREAM); if (vect.size() < 0) throw runtime_error("could not resolve host name of SOCKS server"); socks_host_ep = vect[0]; WARN(1, "SOCKS server endpoint: " << socks_host_ep->toStr()); Socket s(AF_INET, SOCK_STREAM, 0); IPEndPoint ep(IPAddress("0.0.0.0"), iptsocks_params.tcp_port); s.bind(ep); s.listen(); p.add(s); struct { Poll& p; void operator()(HANDLE h) { iptsocks_connection* conn = new iptsocks_connection(p, h); conn->release(); } } cb1 { p }; s.repeatAcceptHandle(&cb1); struct { void operator()(DNSServer& srv, const EndPoint& ep, const DNSServer::dnsreq& req) { WARN(6, "RECEIVED DNS PACKET"); /*auto tmp=pool.get(); if(tmp.second)ip=tmp.first; else ip=IPAddress("127.0.0.1");*/ DNSServer::dnsreq resp(req.create_answer()); IPAddress ip1[resp.queries.size()]; for (int i = 0; i < (int) resp.queries.size(); i++) { //only support A record lookups if (resp.queries[i].type != 1) continue; ip1[i] = map_host(resp.queries[i].q); DNSServer::answer a { i, resp.queries[i].type, resp.queries[i].cls, 100000000, string { (const char*) &ip1[i].a, sizeof(ip1[i].a) } }; resp.answers.push_back(a); } srv.sendreply(ep, resp); } ; } answer_request; DNSServer* srv; srv = new DNSServer(p, IPEndPoint(IPAddress("127.0.0.1"), iptsocks_params.dns_port), &answer_request); srv->start(); DNSServer* srv1; srv1 = new DNSServer(p, IPEndPoint(IPAddress("0.0.0.0"), iptsocks_params.dns_port), &answer_request); srv1->start(); WARN(2, "started. accepting commands on stdin: ls - list all allocated IPs; lsu - list unreferenced IPs in cache"); StandardStream ss; StreamBuffer sbuf(ss); StreamWriter sw(sbuf); ss.addToPoll(p); StreamReader sr(ss); struct { StreamReader& sr; StreamWriter& sw; void operator()(string l) { if (l.length() <= 0) goto sss; if (l.compare("ls") == 0) { for (auto it = hosts.begin(); it != hosts.end(); it++) { sw.writeF("%s: %s\n", (*it).first.toStr().c_str(), (*it).second.host.c_str()); } } else if (l.compare("lsu") == 0) { for (auto it = unused_hosts.begin(); it != unused_hosts.end(); it++) { sw.writeF("%s: %s\n", (*it).second.toStr().c_str(), hosts[(*it).second].host.c_str()); } } else { sw.write("unknown command\n"); } sw.flush(); sss: if (!sr.eof) begin(); } void begin() { sr.readLine(this); } } cmdcb { sr, sw }; cmdcb.begin(); p.loop(); return 0; }
int main() { StandardStream ss; struct handler { Ref<Stream> s1,s2; list<Buffer> queue; list<Buffer>::iterator last_written; bufferManager bm; Buffer rbuf; vector<iovec> iovecs; bool writing=false; bool shouldExit=false; void startR1() { rbuf=bm.beginGet(); s1->read(rbuf,{&handler::cbR1,this}); } void cbR1(int r) { if(r<=0) { if(writing) shouldExit=true; else exit(0); } bm.endGet(r); rbuf.clip(0,r); queue.push_back(rbuf); rbuf.release(); startW2(); startR1(); } void startW2() { if(writing) return; if(queue.size()<=0) { if(shouldExit)exit(0); return; } writing=true; iovecs.resize(queue.size()); auto it=queue.begin(); for(int i=0;i<iovecs.size();i++) { iovecs[i].iov_base=(*it).data(); iovecs[i].iov_len=(*it).length(); it++; } last_written=it; s2->writevAll(&iovecs[0],iovecs.size(),{&handler::cbW2,this}); } void cbW2(int r) { //printf("cbW2: %i\n",r); if(r<=0) exit(0); queue.erase(queue.begin(),last_written); writing=false; startW2(); } handler(Stream& s1, Stream& s2):s1(&s1),s2(&s2) { startR1(); } } h(ss,ss); Poll p; ss.addToPoll(p); ss.setBlocking(false); p.loop(); }
int main() { Poll poll; Scene &scene = poll.scene_get(); Node *camera_node = scene.node_camera_get(); auto plugin_debug = std::unique_ptr<Plugin_Debug>(new Plugin_Debug(poll.console_get(), scene)); auto plugin_light_tool = std::unique_ptr<Plugin_Light_Tool>(new Plugin_Light_Tool(poll.console_get(), scene)); auto plugin_node_tool = std::unique_ptr<Plugin_Node_Tool>(new Plugin_Node_Tool(poll.console_get(), scene, 0.7f)); auto plugin_firstperson_camera = std::unique_ptr<Plugin_Firstperson_Camera>(new Plugin_Firstperson_Camera(poll.console_get(), scene, camera_node)); poll.plugin_add(*plugin_debug); poll.plugin_add(*plugin_light_tool); poll.plugin_add(*plugin_firstperson_camera); poll.plugin_add(*plugin_node_tool); const float scene_scalar = 0.7; Node &root = scene.node_root_get(); root.scale(scene, glm::vec3(scene_scalar, scene_scalar, scene_scalar)); // Node &sponza = scene.load("data/crytek-sponza/", "sponza_with_spec.obj", MODEL_IMPORT_DEFAULT); // sponza.scale(scene, glm::vec3(0.05, 0.05, 0.05)); { Node &floor = scene.load("data/demo_room/floor/", "floor.obj", MODEL_IMPORT_OPTIMIZED ); Material *material = floor.material_get(); vec3 v(0.5, 0.5, 0.5); material->color_set(v, v, v, 1); } { Node &backdrop= scene.load("data/demo_room/backdrop/", "backdrop.dae", MODEL_IMPORT_OPTIMIZED); backdrop.rotate(scene, M_PI, vec3(0, 1, 0)); backdrop.translate(scene, vec3(-25.f * scene_scalar, 0, 0)); Node &zombie = scene.load("data/zombie/", "new_thin_zombie.dae", MODEL_IMPORT_OPTIMIZED); zombie.rotate(scene, (float) M_PI / 2.f, vec3(0, 0, 1)); zombie.translate(scene, vec3(-18 * scene_scalar, -12.5 * scene_scalar, 9 * scene_scalar)); } { Node &backdrop= scene.load("data/demo_room/backdrop/", "backdrop.dae", MODEL_IMPORT_OPTIMIZED); backdrop.rotate(scene, M_PI, vec3(0, 1, 0)); backdrop.translate(scene, vec3(-10.f * scene_scalar, 0, 0)); Node &teapot= scene.load("data/demo_room/teapot/", "teapot.obj", MODEL_IMPORT_DEFAULT); teapot.translate(scene, vec3(-8 * scene_scalar, 2.5 * scene_scalar, 0)); teapot.scale(scene, vec3(0.02, 0.02, 0.02)); Node &teapot_no_shadow = scene.load("data/demo_room/teapot/", "teapot.obj", MODEL_IMPORT_DEFAULT); teapot_no_shadow.translate(scene, vec3(-12 * scene_scalar, 2.5 * scene_scalar, 0)); teapot_no_shadow.scale(scene, vec3(0.02, 0.02, 0.02)); for (auto &child: teapot_no_shadow.children_get()) { child->shadow_cast_set(scene, true); } } { Node &mitsuba = scene.load("data/demo_room/mitsuba/", "mitsuba.obj", MODEL_IMPORT_DEFAULT); mitsuba.translate(scene, vec3(5 * scene_scalar, 0, 0)); } { Node &mitsuba = scene.load("data/demo_room/mitsuba/", "mitsuba.obj", MODEL_IMPORT_DEFAULT); mitsuba.translate(scene, vec3(20.f * scene_scalar, 0, 0)); } /* std::vector<std::unique_ptr<Physics_Triangle_Mesh_Shape>> shapes; for (auto &child: cube.children_get()) { if (!child->mesh_get()) continue; auto shape = std::unique_ptr<Physics_Triangle_Mesh_Shape>(new Physics_Triangle_Mesh_Shape(*child)); Physics_Rigidbody *rigidbody = child->physics_rigidbody_create(scene); if (rigidbody) { rigidbody->create(scene.physics_get(), *shape, Physics_Rigidbody::DYNAMIC, 0); shapes.push_back(std::move(shape)); } } */ { Node *node = scene.node_create("Light_Directionl_Global"); Light *light = node->light_create(scene, Light::DIRECTIONAL, Light::GLOBAL); node->translate(scene, glm::vec3(0, 40, 0)); light->properties_direction_set(glm::vec3(0, -1, -1)); light->properties_color_set(glm::vec3(0.5, 0.5, 0.5)); } poll.run(); poll.term(); return true; }
int main() { vector<Poll> pollList; while (true) { Poll newPoll; string question; string answers[4]; cout << "POLL #" << pollList.size() << endl; cout << "Enter poll question: "; cin.ignore(); getline(cin, question); for (int i = 0; i < 4; i++) { cout << "Enter answer " << i << ": "; getline(cin, answers[i]); } newPoll.SetQuestion(question); newPoll.SetAnswers(answers[0], answers[1], answers[2], answers[3]); pollList.push_back(newPoll); cout << "Create another? (y/n): "; string choice; cin >> choice; cout << endl << endl; if (choice == "n") { // Leave loop break; } } for (int i = 0; i < pollList.size(); i++) { cout << endl << endl; pollList[i].DisplayPoll(); cout << "VOTE: "; int choice; cin >> choice; pollList[i].Vote(choice); pollList[i].DisplayResults(); cout << "Continue? (y/n): "; string continueChoice; cin >> continueChoice; if (continueChoice == "n") { break; } } return 0; }