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;
//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();
}
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() {
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();
}
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;
}
