repos/Smersh/Smersh.cpp

// Smersh
//
// Douglas Thrift
//
// $Id$

#include "Smersh.hpp"
#include "Matcher.hpp"
#include "Person.hpp"
#include "Daemon.hpp"
#include "Redirector.hpp"

string program;
bool debug(false);

int main(int argc, char* argv[])
{
        program = argv[0];

        int port(8080);
        bool fork(false), daemon(false), redirector(false);
        string redirect;

        for (int index(1); index < argc; ++index)
        {
                string arg(argv[index]);
                Matcher matcher;

                if (arg == "-daemon")
                {
                        if (!daemon) daemon = true;
                }
                else if (arg == matcher("^-redirector=(.+)$"))
                {
                        if (!redirector) redirector = true;

                        redirect = matcher[1];
                }
                else if (arg == matcher("^-port=([0-9]+)$"))
                {
                        port = lexical_cast<int>(matcher[1]);
                }
                else if (arg == "-fork")
                {
                        if (!fork) fork = true;
                }
                else if (arg == "-D")
                {
                        if (!debug) debug = true;
                }
                else
                {
                        cout << "Usage: " << program << " [-daemon|-redirector=redirect] ["
                                << "-port=port] [-fork] [-D]\n";

                        return 1;
                }
        }

        if (daemon)
        {
                Daemon daemon(port, fork);
        }
        else if (redirector)
        {
                Redirector redirector(port, fork, redirect);
        }
        else
        {
                Smersh smersh;
        }

        return 0;
}

Smersh::Smersh(istream& sin, ostream& sout)
{
        parse(sin);
        smersh(sout);
}

void Smersh::parse(istream& sin)
{
        stringstream query(sgetenv("QUERY_STRING"));

        if (sgetenv("REQUEST_METHOD") == "POST")
        {
                streamsize length(lexical_cast<streamsize>(sgetenv("CONTENT_LENGTH")));
                char* content = new char[length];

                sin.read(content, length);
                query.write(content, length);

                delete [] content;
        }
        if (query.str() == "") return;

        do
        {
                string name, value;

                getline(query, name, '=');
                getline(query, value, '&');

                cgi.insert(pair<string, string>(name, value));
        }
        while (query.good());
}

void Smersh::smersh(ostream& sout)
{
        sout << "Content-Type: text/html\n\n";

        vector<Person> people(1);

        for (multimap<string, string>::iterator itor(cgi.lower_bound("sn")); itor
                != cgi.upper_bound("sn"); ++itor)
        {
                string sn(itor->second);

                for (string::size_type index(0); index < sn.length(); ++index)
                {
                        while (!isalnum(sn[index]) && index < sn.length())
                        {
                                if (sn[index] == '%' && index + 2 < sn.length())
                                {
                                        istringstream code(sn.substr(index + 1, 2));
                                        unsigned short character;

                                        code.setf(ios_base::hex, ios_base::basefield);

                                        code >> character;

                                        sn.replace(index, 3, 1, character);

                                        if (isalnum(sn[index])) break;
                                }

                                sn.erase(index, 1);
                        }
                }

                if (debug) cerr << "sn = " << sn << '\n';

                Person person(sn);

                people.push_back(person);

                if (person.isMultiple())
                {
                        people.insert(people.end(), person.beginMultiple(),
                                person.endMultiple());
                        person.clearMultiple();
                }
        }

        if (people.size() > 1)
        {
                people.erase(people.begin());

                sort(people.begin(), people.end());

                people.erase(unique(people.begin(), people.end()), people.end());
        }

        sout << "<html><head><title>Hello, " << flush;

        output(sout, people);

        sout << "!</title></head><body><p style=\"font-variant: small-caps\"><stro"
                << "ng><font face=\"Comic Sans MS\" size=\"4\">Hello, " << flush;

        output(sout, people);

        sout << "!</font></strong></p></body></html>\n";
}

void Smersh::output(ostream& sout, const vector<Person>& people)
{
        for (vector<Person>::const_iterator person(people.begin()); person !=
                people.end(); ++person)
        {
                sout << *person;

                if (person + 2 == people.end())
                {
                        sout << (people.size() > 2 ? "," : "") << " and/or ";
                }
                else if (person + 1 != people.end())
                {
                        sout << ", ";
                }

                sout << flush;
        }
}
Revision:	172
Committed:	2004-06-20T22:47:13-07:00 (21 years ago) by Douglas Thrift
File size:	3546 byte(s)
Log Message:	Moving ahead, slowly.
#	User	Rev	Content
1	Douglas Thrift	162	// Smersh
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7			#include "Smersh.hpp"
8	Douglas Thrift	164	#include "Matcher.hpp"
9	Douglas Thrift	165	#include "Person.hpp"
10			#include "Daemon.hpp"
11			#include "Redirector.hpp"
12	Douglas Thrift	162
13	Douglas Thrift	165	string program;
14			bool debug(false);
15
16	Douglas Thrift	162	int main(int argc, char* argv[])
17			{
18	Douglas Thrift	165	program = argv[0];
19	Douglas Thrift	162
20	Douglas Thrift	165	int port(8080);
21	Douglas Thrift	172	bool fork(false), daemon(false), redirector(false);
22	Douglas Thrift	165	string redirect;
23
24			for (int index(1); index < argc; ++index)
25			{
26			string arg(argv[index]);
27			Matcher matcher;
28
29	Douglas Thrift	172	if (arg == "-daemon")
30	Douglas Thrift	165	{
31			if (!daemon) daemon = true;
32			}
33			else if (arg == matcher("^-redirector=(.+)$"))
34			{
35			if (!redirector) redirector = true;
36
37			redirect = matcher[1];
38			}
39			else if (arg == matcher("^-port=([0-9]+)$"))
40			{
41			port = lexical_cast<int>(matcher[1]);
42			}
43	Douglas Thrift	172	else if (arg == "-fork")
44			{
45			if (!fork) fork = true;
46			}
47			else if (arg == "-D")
48			{
49			if (!debug) debug = true;
50			}
51			else
52			{
53			cout << "Usage: " << program << " [-daemon\|-redirector=redirect] ["
54			<< "-port=port] [-fork] [-D]\n";
55
56			return 1;
57			}
58	Douglas Thrift	165	}
59
60			if (daemon)
61			{
62	Douglas Thrift	172	Daemon daemon(port, fork);
63	Douglas Thrift	165	}
64			else if (redirector)
65			{
66	Douglas Thrift	172	Redirector redirector(port, fork, redirect);
67	Douglas Thrift	165	}
68			else
69			{
70			Smersh smersh;
71			}
72
73	Douglas Thrift	162	return 0;
74			}
75
76	Douglas Thrift	166	Smersh::Smersh(istream& sin, ostream& sout)
77	Douglas Thrift	162	{
78	Douglas Thrift	166	parse(sin);
79			smersh(sout);
80	Douglas Thrift	162	}
81
82	Douglas Thrift	166	void Smersh::parse(istream& sin)
83	Douglas Thrift	162	{
84	Douglas Thrift	172	stringstream query(sgetenv("QUERY_STRING"));
85	Douglas Thrift	162
86	Douglas Thrift	172	if (sgetenv("REQUEST_METHOD") == "POST")
87			{
88			streamsize length(lexical_cast<streamsize>(sgetenv("CONTENT_LENGTH")));
89			char* content = new char[length];
90	Douglas Thrift	162
91	Douglas Thrift	172	sin.read(content, length);
92			query.write(content, length);
93	Douglas Thrift	162
94	Douglas Thrift	172	delete [] content;
95			}
96			if (query.str() == "") return;
97
98	Douglas Thrift	162	do
99			{
100			string name, value;
101
102	Douglas Thrift	172	getline(query, name, '=');
103			getline(query, value, '&');
104	Douglas Thrift	162
105			cgi.insert(pair<string, string>(name, value));
106			}
107	Douglas Thrift	172	while (query.good());
108	Douglas Thrift	162	}
109	Douglas Thrift	166
110			void Smersh::smersh(ostream& sout)
111			{
112			sout << "Content-Type: text/html\n\n";
113
114	Douglas Thrift	167	vector<Person> people(1);
115	Douglas Thrift	166
116			for (multimap<string, string>::iterator itor(cgi.lower_bound("sn")); itor
117			!= cgi.upper_bound("sn"); ++itor)
118			{
119			string sn(itor->second);
120
121			for (string::size_type index(0); index < sn.length(); ++index)
122			{
123	Douglas Thrift	171	while (!isalnum(sn[index]) && index < sn.length())
124	Douglas Thrift	167	{
125	Douglas Thrift	171	if (sn[index] == '%' && index + 2 < sn.length())
126			{
127			istringstream code(sn.substr(index + 1, 2));
128			unsigned short character;
129	Douglas Thrift	167
130	Douglas Thrift	171	code.setf(ios_base::hex, ios_base::basefield);
131	Douglas Thrift	167
132	Douglas Thrift	171	code >> character;
133	Douglas Thrift	167
134	Douglas Thrift	171	sn.replace(index, 3, 1, character);
135	Douglas Thrift	167
136	Douglas Thrift	171	if (isalnum(sn[index])) break;
137			}
138
139	Douglas Thrift	166	sn.erase(index, 1);
140			}
141			}
142
143	Douglas Thrift	170	if (debug) cerr << "sn = " << sn << '\n';
144
145	Douglas Thrift	166	Person person(sn);
146
147			people.push_back(person);
148
149			if (person.isMultiple())
150			{
151			people.insert(people.end(), person.beginMultiple(),
152			person.endMultiple());
153			person.clearMultiple();
154			}
155			}
156
157	Douglas Thrift	167	if (people.size() > 1)
158			{
159			people.erase(people.begin());
160
161			sort(people.begin(), people.end());
162
163			people.erase(unique(people.begin(), people.end()), people.end());
164			}
165
166	Douglas Thrift	166	sout << "<html><head><title>Hello, " << flush;
167
168			output(sout, people);
169
170			sout << "!</title></head><body><p style=\"font-variant: small-caps\"><stro"
171			<< "ng><font face=\"Comic Sans MS\" size=\"4\">Hello, " << flush;
172
173			output(sout, people);
174
175			sout << "!</font></strong></p></body></html>\n";
176			}
177
178			void Smersh::output(ostream& sout, const vector<Person>& people)
179			{
180			for (vector<Person>::const_iterator person(people.begin()); person !=
181			people.end(); ++person)
182			{
183			sout << *person;
184
185			if (person + 2 == people.end())
186			{
187	Douglas Thrift	167	sout << (people.size() > 2 ? "," : "") << " and/or ";
188	Douglas Thrift	166	}
189			else if (person + 1 != people.end())
190			{
191			sout << ", ";
192			}
193
194			sout << flush;
195			}
196			}