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