├── assets
    └── clippy.swf
├── permgen.cpp
├── test.cpp
├── .github
    └── workflows
    │   └── test.yml
├── permgen.h
├── CMake
    ├── FindSqlite3.cmake
    ├── FindFCGIPP.cmake
    └── FindCppUnit.cmake
├── error.html
├── insults.txt
├── test_permgen.cpp
├── insults.h
├── README.md
├── index.html
├── database.h
├── created.html
├── CMakeLists.txt
├── Vagrantfile
├── test_insults.cpp
├── template.h
├── test_database.cpp
├── insults.cpp
├── test_template.cpp
├── template.cpp
├── database.cpp
└── cgi.cpp


/assets/clippy.swf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/remram44/insurlt/HEAD/assets/clippy.swf


--------------------------------------------------------------------------------
/permgen.cpp:
--------------------------------------------------------------------------------
 1 | #include "permgen.h"
 2 | 
 3 | 
 4 | constexpr Key M = 0xFFFFFFFF;
 5 | constexpr Key A = 1103515245;
 6 | constexpr Key C = 12345;
 7 | 
 8 | Generator::Generator(Key max)
 9 |   : m_Max(max)
10 | {
11 | }
12 | 
13 | Key Generator::generate(Key state)
14 | {
15 |     do
16 |         state = (A * state + C) & M;
17 |     while(state > m_Max);
18 |     return state;
19 | }
20 | 


--------------------------------------------------------------------------------
/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <cppunit/extensions/TestFactoryRegistry.h>
 2 | #include <cppunit/ui/text/TestRunner.h>
 3 | 
 4 | 
 5 | int main()
 6 | {
 7 |     CppUnit::TextUi::TestRunner runner;
 8 |     CppUnit::TestFactoryRegistry &registry =
 9 |             CppUnit::TestFactoryRegistry::getRegistry();
10 |     runner.addTest(registry.makeTest());
11 |     bool wasSuccessful = runner.run("", false);
12 |     return !wasSuccessful;
13 | }
14 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: Test
 2 | 
 3 | on:
 4 |   - push
 5 |   - pull_request
 6 | 
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 |     - name: Install dependencies
13 |       run: |
14 |         sudo apt-get update -qq
15 |         sudo apt-get install -qq libfcgi-dev libsqlite3-dev libcppunit-dev
16 |     - name: Build
17 |       run: |
18 |         mkdir ../build
19 |         cd ../build
20 |         cmake ../insurlt -DBUILD_TESTS:BOOL=on
21 |         make -j2
22 |     - name: Run tests
23 |       run: ../build/tests
24 | 


--------------------------------------------------------------------------------
/permgen.h:
--------------------------------------------------------------------------------
 1 | #ifndef PERMGEN_H
 2 | #define PERMGEN_H
 3 | 
 4 | #include <cstdint>
 5 | 
 6 | 
 7 | typedef std::uint_fast32_t Key;
 8 | 
 9 | 
10 | /**
11 |  * Generates a random permutation on 32-bit integers.
12 |  *
13 |  * Warning: max should be set to a value close to 2^32. Generation will take
14 |  * mean time proportional to 2^32/max
15 |  */
16 | class Generator {
17 | 
18 | private:
19 |     const Key m_Max;
20 | 
21 | public:
22 |     /**
23 |      * Constructor.
24 |      *
25 |      * @param max Maximum number to return (inclusive).
26 |      */
27 |     Generator(Key max);
28 |     Key generate(Key previous);
29 | 
30 | };
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/CMake/FindSqlite3.cmake:
--------------------------------------------------------------------------------
 1 | # Look for the header file.
 2 | FIND_PATH(SQLITE3_INCLUDE_DIR NAMES sqlite3.h)
 3 | 
 4 | # Look for the library.
 5 | FIND_LIBRARY(SQLITE3_LIBRARY NAMES sqlite3)
 6 | 
 7 | # Handle the QUIETLY and REQUIRED arguments and set Sqlite3_FOUND to TRUE if all listed variables are TRUE.
 8 | INCLUDE(FindPackageHandleStandardArgs)
 9 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(Sqlite3 DEFAULT_MSG SQLITE3_LIBRARY SQLITE3_INCLUDE_DIR)
10 | 
11 | # Copy the results to the output variables.
12 | IF(SQLITE3_FOUND)
13 |     SET(SQLITE3_LIBRARIES ${SQLITE3_LIBRARY})
14 |     SET(SQLITE3_INCLUDE_DIRS ${SQLITE3_INCLUDE_DIR})
15 | ELSE(Sqlite3_FOUND)
16 |     SET(SQLITE3_LIBRARIES)
17 |     SET(SQLITE3_INCLUDE_DIRS)
18 | ENDIF(SQLITE3_FOUND)
19 | 
20 | MARK_AS_ADVANCED(SQLITE3_INCLUDE_DIR SQLITE3_LIBRARY)
21 | 


--------------------------------------------------------------------------------
/CMake/FindFCGIPP.cmake:
--------------------------------------------------------------------------------
 1 | # Look for the header file.
 2 | FIND_PATH(FCGIPP_INCLUDE_DIR NAMES fastcgi.h)
 3 | 
 4 | # Look for the library.
 5 | FIND_LIBRARY(FCGI_LIBRARY NAMES fcgi)
 6 | FIND_LIBRARY(FCGIPP_LIBRARY NAMES fcgi++)
 7 | 
 8 | # Handle the QUIETLY and REQUIRED arguments and set FCGIPP_FOUND to TRUE if all listed variables are TRUE.
 9 | INCLUDE(FindPackageHandleStandardArgs)
10 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(FCGIPP DEFAULT_MSG FCGI_LIBRARY FCGIPP_LIBRARY FCGIPP_INCLUDE_DIR)
11 | 
12 | # Copy the results to the output variables.
13 | IF(FCGIPP_FOUND)
14 |     SET(FCGIPP_LIBRARIES ${FCGI_LIBRARY} ${FCGIPP_LIBRARY})
15 |     SET(FCGIPP_INCLUDE_DIRS ${FCGIPP_INCLUDE_DIR})
16 | ELSE(FCGIPP_FOUND)
17 |     SET(FCGIPP_LIBRARIES)
18 |     SET(FCGIPP_INCLUDE_DIRS)
19 | ENDIF(FCGIPP_FOUND)
20 | 
21 | MARK_AS_ADVANCED(FCGIPP_INCLUDE_DIR FCGI_LIBRARY FCGIPP_LIBRARY)
22 | 


--------------------------------------------------------------------------------
/error.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="fr-FR">
 3 | <head>
 4 |     <title>La r&#233;surrection du rallongeur d'URL de Nicolas ANELKA</title>
 5 |     <style type="text/css">
 6 |         body {
 7 |             text-align: center;
 8 |             margin-left: 25%;
 9 |             margin-right: 25%;
10 |             font-family: 'Trebuchet MS', Helvetica, sans-serif;
11 |             font-size: small;
12 |             background: #666;
13 |         }
14 |         div {
15 |             border: 1px solid;
16 |             padding: 2em;
17 |             background: #fff;
18 |             min-width: 400px;
19 |             min-height: 250px;
20 |         }
21 |     </style>
22 | </head>
23 | <body>
24 |     <div>
25 |         <h1>{{ message }}</h1>
26 |         <p><a href="http://clique-salope.ovh/">Retourne &agrave; l'index, salope.</a></p>
27 |     </div>
28 | </body>
29 | </html>
30 | 


--------------------------------------------------------------------------------
/insults.txt:
--------------------------------------------------------------------------------
 1 | vas-y clique <N> ou <V> <O> <L> <I> allez.clique-salope.com
 2 | 
 3 | N:
 4 |     salope
 5 |     gros con
 6 |     pauvre con
 7 |     sale fils de pute
 8 |     petite bite
 9 |     fils de chienne
10 |     grosse merde
11 |     vieux chacal
12 |     sale encule
13 |     gros batard
14 | V:
15 |     va trouer le cul de
16 |     va gifler
17 |     va defoncer l-anus de
18 |     va tuer
19 |     va crever
20 |     va cracher sur
21 | O:
22 |     ta fille
23 |     ta grand mere
24 |     ton grand pere
25 |     ton chien
26 |     ta femme
27 |     ta chienne
28 |     ta soeur
29 |     ton frere
30 | L:
31 |     au cimetiere
32 |     chez le coiffeur
33 |     dans ma cave
34 |     dans la cave
35 |     sous ma caisse
36 |     dans les champs
37 |     dans ton cul
38 |     dans la niche
39 |     a carrefour
40 | I:
41 |     raclure de chiottes
42 |     face de pet
43 |     sous merde
44 |     sale batard
45 |     pauvre merde
46 |     fils de chien
47 |     grosse pute
48 |     sale enflure
49 |     petite catin
50 | 
51 | Each space can be either . or -, total: 3609722880 possibilities
52 | 


--------------------------------------------------------------------------------
/test_permgen.cpp:
--------------------------------------------------------------------------------
 1 | #include <cppunit/extensions/HelperMacros.h>
 2 | 
 3 | #include "permgen.h"
 4 | 
 5 | 
 6 | class PermGen_test : public CppUnit::TestFixture {
 7 | 
 8 | public:
 9 |     void test_generate()
10 |     {
11 |         std::vector<Key> keys;
12 |         {
13 |             Generator gen(3456789012);
14 |             Key state = 0;
15 |             for(size_t i = 0; i < 10; ++i)
16 |             {
17 |                 state = gen.generate(state);
18 |                 CPPUNIT_ASSERT(state <= 3456789012);
19 |                 keys.push_back(state);
20 |             }
21 |         }
22 |         {
23 |             Generator gen2(3456789012);
24 |             Key state = keys[4];
25 |             for(size_t i = 0; i < 5; ++i)
26 |             {
27 |                 state = gen2.generate(state);
28 |                 CPPUNIT_ASSERT(state == keys[5+i]);
29 |             }
30 |         }
31 |     }
32 | 
33 |     CPPUNIT_TEST_SUITE(PermGen_test);
34 |     CPPUNIT_TEST(test_generate);
35 |     CPPUNIT_TEST_SUITE_END();
36 | 
37 | };
38 | 
39 | CPPUNIT_TEST_SUITE_REGISTRATION(PermGen_test);
40 | 


--------------------------------------------------------------------------------
/insults.h:
--------------------------------------------------------------------------------
 1 | #ifndef INSULTS_H
 2 | #define INSULTS_H
 3 | 
 4 | #include <initializer_list>
 5 | #include <string>
 6 | #include <vector>
 7 | 
 8 | #include "permgen.h"
 9 | 
10 | 
11 | class Chooser {
12 | 
13 | private:
14 |     std::vector<std::string> m_Choices;
15 | 
16 | private:
17 |     void gen_choices(const std::string &orig, size_t index,
18 |                      const std::string &prefix);
19 | 
20 | public:
21 |     Chooser(std::initializer_list<const char*> choices);
22 |     const std::string &operator()(Key &key) const;
23 |     size_t size() const;
24 | 
25 | };
26 | 
27 | 
28 | class CombinedChoosers {
29 | 
30 | private:
31 |     std::vector<Chooser> m_Choosers;
32 | 
33 | public:
34 |     CombinedChoosers(std::initializer_list<Chooser> choosers);
35 |     std::string operator()(Key key) const;
36 |     size_t size() const;
37 | 
38 | };
39 | 
40 | 
41 | class Insults {
42 | 
43 | private:
44 |     CombinedChoosers m_Choosers;
45 | 
46 | public:
47 |     static constexpr Key CHOICES = 3609722880;
48 | 
49 |     Insults();
50 |     std::string generate(Key state);
51 | 
52 | };
53 | 
54 | #endif
55 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # insurlt: An offensive URL-lengthener service
 2 | 
 3 | [![Build Status](https://github.com/remram44/insurlt/workflows/Test/badge.svg)](https://github.com/remram44/insurlt/actions) [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/remram44)
 4 | 
 5 | # Introduction
 6 | 
 7 | This is a webapp that creates redirects to user-supplied URLs, the same way the
 8 | more common URL-shortener services do (bit.ly, goo.gl, t.co). Except it makes
 9 | them very long, and full of obscenities.
10 | 
11 | It is written in C++, the obvious tool for the job.
12 | 
13 | This service used to exist as clique-salope.com, however it looks like it has
14 | now been discontinued. Being such an important piece of the modern Internet,
15 | someone had to put it back online.
16 | 
17 | # How to setup
18 | 
19 | You will need CMake, SQLite3, the fastcgi development kit, and a C++11
20 | compiler like GCC >=4.6 or Clang >=2.9.
21 | 
22 | Simply configure your web server to point to the insurlt.fcgi binary. You will
23 | need to update the source to match your domain name and favorite insults.
24 | 
25 | # Check it out
26 | 
27 | http://clique-salope.ovh/ (original French version)
28 | http://click-bitch.ovh/ (English translation)
29 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="fr-FR">
 3 | <head>
 4 |     <title>La r&#233;surrection du rallongeur d'URL de Nicolas ANELKA</title>
 5 |     <style type="text/css">
 6 |         body {
 7 |             text-align: center;
 8 |             margin-left: 25%;
 9 |             margin-right: 25%;
10 |             font-family: 'Trebuchet MS', Helvetica, sans-serif;
11 |             font-size: small;
12 |             background: #666;
13 |         }
14 |         #shortbitchurl {
15 |             width: 400px;
16 |         }
17 |         div {
18 |             border: 1px solid;
19 |             padding: 2em;
20 |             background: #fff;
21 |             min-width: 400px;
22 |             min-height: 250px;
23 |         }
24 |     </style>
25 | </head>
26 | <body>
27 |     <div>
28 |         <h1>Le rallongeur d'URL de la r&#233;surrection de Nicolas ANELKA</h1>
29 |         <h2>Le rallongeur de r&#233;surrection d'URL de Nicolas ANELKA</h2>
30 |         <h3>L'URL de la r&#233;surrection du rallongeur de Nicolas ANELKA</h3>
31 |         <h4>Oh, ta gueule et clique, salope.</h4>
32 |         <form action="/" method="post">
33 |             <input type="url" name="url" />
34 |             <input type="submit" value="Allez !" />
35 |         </form>
36 |     </div>
37 | </body>
38 | </html>
39 | 


--------------------------------------------------------------------------------
/database.h:
--------------------------------------------------------------------------------
 1 | #ifndef DATABASE_H
 2 | #define DATABASE_H
 3 | 
 4 | #include <exception>
 5 | #include <sqlite3.h>
 6 | 
 7 | #include "permgen.h"
 8 | 
 9 | 
10 | class DatabaseError : std::exception {
11 | 
12 | private:
13 |     const std::string m_Message;
14 | 
15 | public:
16 |     DatabaseError(const std::string &msg);
17 |     ~DatabaseError() throw();
18 |     const char *what() const throw();
19 | 
20 | };
21 | 
22 | 
23 | /**
24 |  * The Database stores the URLs and the state of the generator.
25 |  */
26 | class Database {
27 | 
28 | private:
29 |     Generator &m_Generator;
30 | 
31 |     sqlite3 *m_DB;
32 | 
33 |     sqlite3_stmt *m_stmtGetState;
34 |     sqlite3_stmt *m_stmtSetState;
35 |     sqlite3_stmt *m_stmtInsertURL;
36 |     sqlite3_stmt *m_stmtGetURL;
37 |     sqlite3_stmt *m_stmtIncrementURLViews;
38 |     sqlite3_stmt *m_stmtGetViews;
39 |     sqlite3_stmt *m_stmtBegin;
40 |     sqlite3_stmt *m_stmtCommit;
41 |     sqlite3_stmt *m_stmtRollback;
42 | 
43 | protected:
44 |     void incrementViews(const std::string &our_url) throw(DatabaseError);
45 | 
46 | public:
47 |     Database(const char *filepath, Generator &generator) throw(DatabaseError);
48 |     ~Database();
49 | 
50 |     void storeURL(const std::string &our_url,
51 |                   const std::string &their_url,
52 |                   const std::string &their_address) throw(DatabaseError);
53 |     std::string resolveURL(const std::string &our_url,
54 |                            bool increment_views) throw(DatabaseError);
55 | 
56 |     unsigned int getViews(const std::string &our_url) throw(DatabaseError);
57 | 
58 |     sqlite3_int64 getState() throw(DatabaseError);
59 |     void setState(sqlite3_int64 state) throw(DatabaseError);
60 |     Key nextState() throw(DatabaseError);
61 | 
62 | };
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/created.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="fr-FR">
 3 | <head>
 4 |     <title>La r&#233;surrection du rallongeur d'URL de Nicolas ANELKA</title>
 5 |     <style type="text/css">
 6 |         body {
 7 |             text-align: center;
 8 |             margin-left: 25%;
 9 |             margin-right: 25%;
10 |             font-family: 'Trebuchet MS', Helvetica, sans-serif;
11 |             font-size: small;
12 |             background: #666;
13 |         }
14 |         #longjerkurl {
15 |             width: 400px;
16 |         }
17 |         div {
18 |             border: 1px solid;
19 |             padding: 2em;
20 |             background: #fff;
21 |             min-width: 400px;
22 |         }
23 |     </style>
24 | </head>
25 | <body>
26 |     <div>
27 |         <h2>C'est long, hein.</h2>
28 |         <input type="url" id="longjerkurl" readonly value="{{ url }}" onclick="select()" />
29 |         <object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
30 |                 width="110"
31 |                 height="14"
32 |                 id="clippy" >
33 |         <param name="movie" value="/clippy.swf"/>
34 |         <param name="allowScriptAccess" value="always" />
35 |         <param name="quality" value="high" />
36 |         <param name="scale" value="noscale" />
37 |         <param NAME="FlashVars" value="text={{ url }}">
38 |         <param name="bgcolor" value="#666">
39 |         <embed src="/clippy.swf"
40 |                width="110"
41 |                height="14"
42 |                name="clippy"
43 |                quality="high"
44 |                allowScriptAccess="always"
45 |                type="application/x-shockwave-flash"
46 |                pluginspage="http://www.macromedia.com/go/getflashplayer"
47 |                FlashVars="text={{ url }}"
48 |                bgcolor="#666"
49 |         />
50 |         </object>
51 |     </div>
52 | </body>
53 | </html>
54 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 2 | PROJECT(insurlt)
 3 | 
 4 | IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
 5 |         "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 6 |     SET(CMAKE_CXX_FLAGS "-Wall -std=c++0x")
 7 | ENDIF()
 8 | 
 9 | SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMake ${CMAKE_MODULE_PATH})
10 | 
11 | FIND_PACKAGE(FCGIPP REQUIRED)
12 | INCLUDE_DIRECTORIES(${FCGIPP_INCLUDE_DIRS})
13 | SET(EXTRA_LIBRARIES ${FCGIPP_LIBRARIES} ${EXTRA_LIBRARIES})
14 | 
15 | FIND_PACKAGE(Sqlite3 REQUIRED)
16 | INCLUDE_DIRECTORIES(${SQLITE3_INCLUDE_DIRS})
17 | SET(EXTRA_LIBRARIES ${SQLITE3_LIBRARIES} ${EXTRA_LIBRARIES})
18 | 
19 | # Makes public/ directory
20 | ADD_CUSTOM_TARGET(
21 |     public
22 |     COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/public")
23 | 
24 | # Copies assets
25 | ADD_CUSTOM_TARGET(
26 |     assets ALL
27 |     COMMAND ${CMAKE_COMMAND} -E copy_if_different
28 |     ${CMAKE_SOURCE_DIR}/assets/clippy.swf
29 |     "${CMAKE_BINARY_DIR}/public/clippy.swf")
30 | 
31 | # Build source list
32 | SET(INSURLT_FILES permgen.cpp insults.cpp database.cpp template.cpp)
33 | 
34 | # Build executable
35 | ADD_EXECUTABLE(insurlt cgi.cpp ${INSURLT_FILES})
36 | TARGET_LINK_LIBRARIES(insurlt ${EXTRA_LIBRARIES})
37 | SET_TARGET_PROPERTIES(
38 |     insurlt PROPERTIES
39 |     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/public"
40 |     OUTPUT_NAME "insurlt.fcgi")
41 | ADD_DEPENDENCIES(insurlt public)
42 | 
43 | # Test binary
44 | OPTION(BUILD_TESTS "Build the tests program" OFF)
45 | IF(BUILD_TESTS)
46 |     FIND_PACKAGE(CppUnit REQUIRED)
47 |     INCLUDE_DIRECTORIES(${CPPUNIT_INCLUDE_DIRS})
48 | 
49 |     SET(TESTS_FILES test.cpp
50 |         test_permgen.cpp test_insults.cpp test_database.cpp test_template.cpp
51 |         ${INSURLT_FILES})
52 | 
53 |     ADD_EXECUTABLE(tests ${TESTS_FILES})
54 |     TARGET_LINK_LIBRARIES(tests ${EXTRA_LIBRARIES} ${CPPUNIT_LIBRARIES})
55 | ENDIF()
56 | 


--------------------------------------------------------------------------------
/CMake/FindCppUnit.cmake:
--------------------------------------------------------------------------------
 1 | # - Find CppUnit
 2 | # Find the CppUnit libraries
 3 | #
 4 | #  This module defines the following variables:
 5 | #     CPPUNIT_FOUND    - True if CPPUNIT_INCLUDE_DIR & CPPUNIT_LIBRARY are found
 6 | #     CPPUNIT_LIBRARIES - Set when CPPUNIT_LIBRARY is found
 7 | #     CPPUNIT_INCLUDE_DIRS - Set when CPPUNIT_INCLUDE_DIR is found
 8 | #
 9 | #     CPPUNIT_INCLUDE_DIR - where to find asoundlib.h, etc.
10 | #     CPPUNIT_LIBRARY  - the CppUnit library
11 | #
12 | 
13 | #=============================================================================
14 | # Adapted from FindALSA.cmake by Remi Rampin, 2014.
15 | #=============================================================================
16 | # Copyright 2009-2011 Kitware, Inc.
17 | # Copyright 2009-2011 Philip Lowman <philip@yhbt.com>
18 | #
19 | # Distributed under the OSI-approved BSD License (the "License");
20 | # see accompanying file Copyright.txt for details.
21 | #
22 | # This software is distributed WITHOUT ANY WARRANTY; without even the
23 | # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
24 | # See the License for more information.
25 | #=============================================================================
26 | # (To distribute this file outside of CMake, substitute the full
27 | #  License text for the above reference.)
28 | 
29 | find_path(CPPUNIT_INCLUDE_DIR NAMES cppunit/ui/text/TestRunner.h
30 |           DOC "The CppUnit include directory"
31 | )
32 | 
33 | find_library(CPPUNIT_LIBRARY NAMES cppunit
34 |           DOC "The CppUnit library"
35 | )
36 | 
37 | # handle the QUIETLY and REQUIRED arguments and set CPPUNIT_FOUND to TRUE if
38 | # all listed variables are TRUE
39 | include(FindPackageHandleStandardArgs)
40 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(CppUnit
41 |                                   REQUIRED_VARS CPPUNIT_LIBRARY CPPUNIT_INCLUDE_DIR)
42 | 
43 | if(CPPUNIT_FOUND)
44 |   set( CPPUNIT_LIBRARIES ${CPPUNIT_LIBRARY} )
45 |   set( CPPUNIT_INCLUDE_DIRS ${CPPUNIT_INCLUDE_DIR} )
46 | endif()
47 | 
48 | mark_as_advanced(CPPUNIT_INCLUDE_DIR CPPUNIT_LIBRARY)
49 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | VAGRANTFILE_API_VERSION = "2"
 5 | 
 6 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
 7 |   config.vm.box = "remram/debian-7-amd64"
 8 | 
 9 |   config.vm.provision "shell",
10 |     inline: <<SCRIPT
11 | sudo aptitude update -y
12 | sudo aptitude install -y g++ cmake libsqlite3-dev libcppunit-dev libfcgi-dev
13 | sudo -u vagrant sh <<NESTED
14 | cd /home/vagrant
15 | mkdir build
16 | cd build
17 | cmake /vagrant -DBUILD_TESTS=on
18 | make
19 | ./tests
20 | NESTED
21 | sudo aptitude install -y apache2 libapache2-mod-fcgid curl
22 | sudo a2enmod fcgid rewrite
23 | sudo cat > /etc/apache2/sites-available/insurlt <<'NESTED'
24 | <VirtualHost *>
25 |     ServerAdmin webmaster@localhost
26 | 
27 |     DocumentRoot /home/vagrant/build/public/
28 | 
29 |     RewriteEngine on
30 |     RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-d
31 |     RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-f
32 |     RewriteRule ^(.*)$ /insurlt.fcgi [L,H=fcgid-script]
33 | 
34 |     FcgidInitialEnv DATABASE_PATH /tmp/database.sqlite3
35 |     FcgidInitialEnv TEMPLATES_PATH /vagrant
36 | 
37 |     <Location />
38 |         AddHandler fcgid-script .fcgi
39 |         Options +ExecCGI
40 |         Order allow,deny
41 |         Allow from all
42 |     </Location>
43 |     <Directory "/home/vagrant/build/public">
44 |         AllowOverride None
45 |         Options +ExecCGI
46 | 
47 |         Order allow,deny
48 |         Allow from all
49 |         Require all granted
50 |         Satisfy Any
51 |     </Directory>
52 | 
53 |     ErrorLog ${APACHE_LOG_DIR}/error.log
54 | 
55 |     # Possible values include: debug, info, notice, warn, error, crit,
56 |     # alert, emerg.
57 |     LogLevel debug
58 | 
59 |     CustomLog ${APACHE_LOG_DIR}/access.log combined
60 | </VirtualHost>
61 | NESTED
62 | sudo rm /etc/apache2/sites-enabled/*
63 | sudo ln -s ../sites-available/insurlt /etc/apache2/sites-enabled/000-insurlt
64 | sudo service apache2 restart
65 | SCRIPT
66 | 
67 |   config.vm.network "forwarded_port", guest: 80, host:8000
68 | end
69 | 


--------------------------------------------------------------------------------
/test_insults.cpp:
--------------------------------------------------------------------------------
 1 | #include <cppunit/extensions/HelperMacros.h>
 2 | 
 3 | #include "insults.h"
 4 | 
 5 | 
 6 | class Insults_test : public CppUnit::TestFixture {
 7 | 
 8 | private:
 9 |     static constexpr size_t NB_GENERATE = 10;
10 |     static const char *expected_insults[NB_GENERATE];
11 | 
12 | public:
13 |     void test_insults()
14 |     {
15 |         Generator gen(Insults::CHOICES);
16 |         Insults insults;
17 |         Key state = 0;
18 |         for(size_t i = 0; i < NB_GENERATE; ++i)
19 |         {
20 |             state = gen.generate(state);
21 |             std::string insult = insults.generate(state);
22 |             CPPUNIT_ASSERT(insult == expected_insults[i]);
23 |         }
24 |     }
25 | 
26 |     CPPUNIT_TEST_SUITE(Insults_test);
27 |     CPPUNIT_TEST(test_insults);
28 |     CPPUNIT_TEST_SUITE_END();
29 | 
30 | };
31 | 
32 | CPPUNIT_TEST_SUITE_REGISTRATION(Insults_test);
33 | 
34 | const char *Insults_test::expected_insults[NB_GENERATE] = {
35 |     "vas-y.clique-sale.fils-de-pute-ou.va.crever.ta.fille."
36 |         "au.cimetiere.raclure.de.chiottes.allez.clique-salope.ovh",
37 |     "vas-y-clique.fils.de-chienne.ou-va.defoncer.l-anus-de.ta-soeur-"
38 |         "sous-ma.caisse.petite-catin-allez.clique-salope.ovh",
39 |     "vas-y-clique-grosse.merde.ou.va.defoncer.l-anus-de.ton.grand.pere-"
40 |         "sous-ma.caisse.pauvre-merde-allez.clique-salope.ovh",
41 |     "vas-y.clique.sale-encule.ou-va-trouer-le-cul.de.ta-grand-mere."
42 |         "dans-les-champs-petite-catin-allez.clique-salope.ovh",
43 |     "vas-y.clique-gros.con.ou.va-trouer.le.cul-de.ta-grand-mere."
44 |         "chez.le-coiffeur.raclure-de-chiottes.allez.clique-salope.ovh",
45 |     "vas-y-clique.sale.encule.ou-va-trouer.le-cul.de-ton.grand.pere-"
46 |         "dans.les-champs.grosse-pute-allez.clique-salope.ovh",
47 |     "vas-y-clique-sale.fils-de-pute-ou.va.gifler.ta.soeur-"
48 |         "a.carrefour-pauvre-merde.allez.clique-salope.ovh",
49 |     "vas-y.clique.salope-ou.va.trouer-le.cul.de.ton.grand.pere-"
50 |         "sous-ma.caisse-sale-enflure-allez.clique-salope.ovh",
51 |     "vas-y.clique-pauvre-con.ou.va.defoncer.l-anus.de.ton-grand.pere-"
52 |         "dans.ma-cave.fils.de-chien-allez.clique-salope.ovh",
53 |     "vas-y-clique.sale-fils-de-pute-ou-va-trouer-le-cul.de.ta.grand-mere."
54 |         "dans-les-champs.face-de-pet.allez.clique-salope.ovh"
55 | };
56 | 


--------------------------------------------------------------------------------
/template.h:
--------------------------------------------------------------------------------
  1 | #ifndef TEMPLATE_H
  2 | #define TEMPLATE_H
  3 | 
  4 | #include <initializer_list>
  5 | #include <stdexcept>
  6 | #include <type_traits>
  7 | #include <utility> // std::pair
  8 | #include <vector>
  9 | 
 10 | 
 11 | class TemplateError : std::exception {
 12 | 
 13 | private:
 14 |     const std::string m_Message;
 15 | 
 16 | public:
 17 |     TemplateError(const std::string &msg);
 18 |     ~TemplateError() throw();
 19 |     const char *what() const throw();
 20 | 
 21 | };
 22 | 
 23 | 
 24 | class VariableProvider {
 25 | 
 26 | public:
 27 |     virtual void handle_variable(std::ostream &out,
 28 |                                  const std::string &name) = 0;
 29 | 
 30 | };
 31 | 
 32 | 
 33 | class EmptyVariableProvider : public VariableProvider {
 34 | 
 35 | public:
 36 |     void handle_variable(std::ostream &out, const std::string &name);
 37 | 
 38 | };
 39 | 
 40 | 
 41 | template<typename Map>
 42 | class MapVariableProvider : public VariableProvider {
 43 | 
 44 | private:
 45 |     const Map &m_Map;
 46 | 
 47 | public:
 48 |     MapVariableProvider(const Map &map)
 49 |       : m_Map(map)
 50 |     {
 51 |     }
 52 | 
 53 |     void handle_variable(std::ostream &out, const std::string &name)
 54 |     {
 55 |         try {
 56 |             out << m_Map.at(name);
 57 |         }
 58 |         catch(std::out_of_range &e)
 59 |         {
 60 |             throw TemplateError("Missing value for variable " + name);
 61 |         }
 62 |     }
 63 | 
 64 | };
 65 | 
 66 | 
 67 | class Template {
 68 | 
 69 | public:
 70 |     enum BlockType {
 71 |         DATA,
 72 |         VARIABLE
 73 |     };
 74 | 
 75 |     typedef std::pair<BlockType, std::string> Block;
 76 | 
 77 | protected:
 78 |     std::vector<Block> m_Blocks;
 79 | 
 80 |     static bool is_space(char c);
 81 | 
 82 | public:
 83 |     Template(const std::string &filename);
 84 |     Template(std::istream &source, const std::string &filename = "<stream>");
 85 |     virtual ~Template();
 86 | 
 87 |     void compile(std::istream &source, const std::string &filename);
 88 | 
 89 |     template<typename Map>
 90 |     typename std::enable_if<
 91 |         !std::is_base_of<VariableProvider, Map>::value,
 92 |         void>::type
 93 |     render(std::ostream &out, const Map &map)
 94 |     {
 95 |         MapVariableProvider<Map> wrapper(map);
 96 |         render(out, wrapper);
 97 |     }
 98 |     void render(std::ostream &out, VariableProvider &vars);
 99 |     void render(std::ostream &out, std::initializer_list<const char*> vars);
100 |     inline void render(std::ostream &out)
101 |     {
102 |         EmptyVariableProvider empty;
103 |         render(out, empty);
104 |     }
105 | 
106 | };
107 | 
108 | #endif
109 | 


--------------------------------------------------------------------------------
/test_database.cpp:
--------------------------------------------------------------------------------
 1 | #include <cppunit/extensions/HelperMacros.h>
 2 | 
 3 | #include "database.h"
 4 | #include "insults.h"
 5 | 
 6 | 
 7 | class Database_test : public CppUnit::TestFixture {
 8 | 
 9 | public:
10 |     void test_state()
11 |     {
12 |         try {
13 |             Generator gen(Insults::CHOICES);
14 |             Database db(":memory:", gen);
15 |             CPPUNIT_ASSERT(db.getState() == 0);
16 |             db.setState(42);
17 |             CPPUNIT_ASSERT(db.getState() == 42);
18 |             db.setState(189);
19 |             Key s = db.nextState();
20 |             CPPUNIT_ASSERT(s == 2405963442);
21 |             CPPUNIT_ASSERT(db.getState() == (sqlite3_int64)s);
22 |             CPPUNIT_ASSERT(db.nextState() == 2246579715);
23 |             CPPUNIT_ASSERT(db.nextState() == 2212002176);
24 |         }
25 |         catch(DatabaseError &e)
26 |         {
27 |             CPPUNIT_FAIL((std::string("Got exception: ") + e.what()).c_str());
28 |         }
29 |     }
30 | 
31 |     void test_urls()
32 |     {
33 |         try {
34 |             Generator gen(Insults::CHOICES);
35 |             Database db(":memory:", gen);
36 |             CPPUNIT_ASSERT(
37 |                     db.resolveURL("http://aaa.clique-salope.ovh/", true) ==
38 |                     "");
39 |             CPPUNIT_ASSERT(
40 |                     db.resolveURL("http://bbb.clique-salope.ovh/", false) ==
41 |                     "");
42 |             db.storeURL("http://aaa.clique-salope.ovh/",
43 |                         "http://aaa.net/", "10.0.0.1");
44 |             CPPUNIT_ASSERT(
45 |                     db.resolveURL("http://aaa.clique-salope.ovh/", false) ==
46 |                     "http://aaa.net/");
47 |             CPPUNIT_ASSERT(
48 |                     db.resolveURL("http://bbb.clique-salope.ovh/", false) ==
49 |                     "");
50 |             CPPUNIT_ASSERT(db.getViews("http://aaa.clique-salope.ovh/") == 0);
51 |             CPPUNIT_ASSERT(
52 |                     db.resolveURL("http://aaa.clique-salope.ovh/", true) ==
53 |                     "http://aaa.net/");
54 |             CPPUNIT_ASSERT(db.getViews("http://aaa.clique-salope.ovh/") == 1);
55 |             CPPUNIT_ASSERT(
56 |                     db.resolveURL("http://bbb.clique-salope.ovh/", true) ==
57 |                     "");
58 |             CPPUNIT_ASSERT(
59 |                     db.resolveURL("http://aaa.clique-salope.ovh/", true) ==
60 |                     "http://aaa.net/");
61 |             CPPUNIT_ASSERT(db.getViews("http://aaa.clique-salope.ovh/") == 2);
62 |         }
63 |         catch(DatabaseError &e)
64 |         {
65 |             CPPUNIT_FAIL((std::string("Got exception: ") + e.what()).c_str());
66 |         }
67 |     }
68 | 
69 |     CPPUNIT_TEST_SUITE(Database_test);
70 |     CPPUNIT_TEST(test_state);
71 |     CPPUNIT_TEST(test_urls);
72 |     CPPUNIT_TEST_SUITE_END();
73 | 
74 | };
75 | 
76 | CPPUNIT_TEST_SUITE_REGISTRATION(Database_test);
77 | 


--------------------------------------------------------------------------------
/insults.cpp:
--------------------------------------------------------------------------------
  1 | #include <cassert>
  2 | 
  3 | #include "insults.h"
  4 | 
  5 | 
  6 | Chooser::Chooser(std::initializer_list<const char*> choices)
  7 | {
  8 |     for(const char *orig : choices)
  9 |         gen_choices(orig, 0, "");
 10 | }
 11 | 
 12 | void Chooser::gen_choices(const std::string &orig, size_t index,
 13 |                           const std::string &prefix)
 14 | {
 15 |     size_t pos = orig.find(' ', index);
 16 |     if(pos == std::string::npos)
 17 |         m_Choices.push_back(prefix + orig.substr(index));
 18 |     else
 19 |     {
 20 |         gen_choices(orig, pos + 1,
 21 |                     prefix + orig.substr(index, pos - index) + ".");
 22 |         gen_choices(orig, pos + 1,
 23 |                     prefix + orig.substr(index, pos - index) + "-");
 24 |     }
 25 | }
 26 | 
 27 | const std::string &Chooser::operator()(Key &key) const
 28 | {
 29 |     size_t p = key % m_Choices.size();
 30 |     key /= m_Choices.size();
 31 |     return m_Choices[p];
 32 | }
 33 | 
 34 | size_t Chooser::size() const
 35 | {
 36 |     return m_Choices.size();
 37 | }
 38 | 
 39 | 
 40 | CombinedChoosers::CombinedChoosers(std::initializer_list<Chooser> choosers)
 41 |   : m_Choosers(choosers)
 42 | {
 43 | }
 44 | 
 45 | std::string CombinedChoosers::operator()(Key key) const
 46 | {
 47 |     std::string result;
 48 |     for(const Chooser &ch : m_Choosers)
 49 |         result += ch(key);
 50 |     return result;
 51 | }
 52 | 
 53 | size_t CombinedChoosers::size() const
 54 | {
 55 |     size_t choices = 1;
 56 |     for(const Chooser &ch : m_Choosers)
 57 |         choices *= ch.size();
 58 |     return choices;
 59 | }
 60 | 
 61 | 
 62 | Insults::Insults()
 63 |   : m_Choosers{
 64 |         Chooser{"vas-y clique "},
 65 |         Chooser{"salope",
 66 |                 "gros con",
 67 |                 "pauvre con",
 68 |                 "sale fils de pute",
 69 |                 "petite bite",
 70 |                 "fils de chienne",
 71 |                 "grosse merde",
 72 |                 "vieux chacal",
 73 |                 "sale encule",
 74 |                 "gros batard"},
 75 |         Chooser{" ou "},
 76 |         Chooser{"va trouer le cul de",
 77 |                 "va gifler",
 78 |                 "va defoncer l-anus de",
 79 |                 "va tuer",
 80 |                 "va crever",
 81 |                 "va cracher sur"},
 82 |         Chooser{" "},
 83 |         Chooser{"ta fille",
 84 |                 "ta grand mere",
 85 |                 "ton grand pere",
 86 |                 "ton chien",
 87 |                 "ta femme",
 88 |                 "ta chienne",
 89 |                 "ta soeur",
 90 |                 "ton frere"},
 91 |         Chooser{" "},
 92 |         Chooser{"au cimetiere",
 93 |                 "chez le coiffeur",
 94 |                 "dans ma cave",
 95 |                 "dans la cave",
 96 |                 "sous ma caisse",
 97 |                 "dans les champs",
 98 |                 "dans ton cul",
 99 |                 "dans la niche",
100 |                 "a carrefour"},
101 |         Chooser{" "},
102 |         Chooser{"raclure de chiottes",
103 |                 "face de pet",
104 |                 "sous merde",
105 |                 "sale batard",
106 |                 "pauvre merde",
107 |                 "fils de chien",
108 |                 "grosse pute",
109 |                 "sale enflure",
110 |                 "petite catin"},
111 |         Chooser{" allez.clique-salope.ovh"}}
112 | {
113 |     assert(m_Choosers.size() == CHOICES);
114 | }
115 | 
116 | std::string Insults::generate(Key state)
117 | {
118 |     return m_Choosers(state);
119 | }
120 | 


--------------------------------------------------------------------------------
/test_template.cpp:
--------------------------------------------------------------------------------
  1 | #include <cppunit/extensions/HelperMacros.h>
  2 | #include <sstream>
  3 | #include <utility>
  4 | #include <unordered_map>
  5 | 
  6 | #define private public
  7 | #define protected public
  8 | #include "template.h"
  9 | 
 10 | 
 11 | class Template_test : public CppUnit::TestFixture {
 12 | 
 13 | public:
 14 |     void test_compile()
 15 |     {
 16 |         std::istringstream stream("Th{{end  }} {{ verb }}: {{\n what}}!");
 17 |         try {
 18 |             Template tpl(stream);
 19 |             std::vector<Template::Block> blocks{
 20 |                 Template::Block(Template::DATA, "Th"),
 21 |                 Template::Block(Template::VARIABLE, "end"),
 22 |                 Template::Block(Template::DATA, " "),
 23 |                 Template::Block(Template::VARIABLE, "verb"),
 24 |                 Template::Block(Template::DATA, ": "),
 25 |                 Template::Block(Template::VARIABLE, "what"),
 26 |                 Template::Block(Template::DATA, "!"),
 27 |             };
 28 |             CPPUNIT_ASSERT(tpl.m_Blocks == blocks);
 29 |         }
 30 |         catch(TemplateError &e)
 31 |         {
 32 |             CPPUNIT_FAIL((std::string("Got exception: ") + e.what()).c_str());
 33 |         }
 34 |     }
 35 | 
 36 |     void test_render()
 37 |     {
 38 |         try {
 39 |             std::istringstream stream("Th{{end  }} {{ verb }}: {{  what}}!");
 40 |             Template tpl(stream);
 41 |             typedef std::pair<std::string, std::string> Item;
 42 | 
 43 |             std::ostringstream oss;
 44 |             tpl.render(
 45 |                     oss,
 46 |                     std::unordered_map<std::string, std::string>{
 47 |                         Item("end", "is"),
 48 |                         Item("verb", "is"),
 49 |                         Item("what", "a house")
 50 |                     });
 51 |             CPPUNIT_ASSERT(oss.str() == "This is: a house!");
 52 | 
 53 |             oss.str("");
 54 |             tpl.render(
 55 |                     oss,
 56 |                     {
 57 |                         "end", "ese",
 58 |                         "verb", "are",
 59 |                         "what", "trees"
 60 |                     });
 61 |             CPPUNIT_ASSERT(oss.str() == "These are: trees!");
 62 | 
 63 |             oss.str("");
 64 |             stream.str("Test2{");
 65 |             Template(stream).render(oss);
 66 |             CPPUNIT_ASSERT(oss.str() == "Test2{");
 67 | 
 68 |             oss.str("");
 69 |             stream.str("Test2{and stuff");
 70 |             Template(stream).render(oss);
 71 |             CPPUNIT_ASSERT(oss.str() == "Test2{and stuff");
 72 |         }
 73 |         catch(TemplateError &e)
 74 |         {
 75 |             CPPUNIT_FAIL((std::string("Got exception: ") + e.what()).c_str());
 76 |         }
 77 |     }
 78 | 
 79 |     void do_error_test(const std::string &expr, bool should_fail)
 80 |     {
 81 |         std::istringstream stream(expr);
 82 |         if(should_fail)
 83 |             CPPUNIT_ASSERT_THROW(Template a(stream), TemplateError);
 84 |         else
 85 |             CPPUNIT_ASSERT_NO_THROW(Template a(stream));
 86 |     }
 87 | 
 88 |     void test_errors()
 89 |     {
 90 |         do_error_test("This{{", true);
 91 |         do_error_test("This{ {is}}", false);
 92 |         do_error_test("This{{is} }", true);
 93 |         do_error_test("This{{is}}", false);
 94 |         do_error_test("This{{is}", true);
 95 |         do_error_test("This{{is", true);
 96 |     }
 97 | 
 98 |     void test_missing_var()
 99 |     {
100 |         try {
101 |             typedef std::pair<std::string, std::string> Item;
102 | 
103 |             std::istringstream stream("Ceci {{is}} un {{test}}");
104 |             Template tpl(stream);
105 |             std::ostringstream oss;
106 |             tpl.render(
107 |                     oss,
108 |                     std::unordered_map<std::string, std::string>{
109 |                         Item("is", "est"),
110 |                         Item("test", "essai")
111 |                     });
112 |             CPPUNIT_ASSERT_THROW(
113 |                 tpl.render(oss, {"is", "est"}),
114 |                 TemplateError);
115 |             CPPUNIT_ASSERT_THROW(
116 |                 tpl.render(oss),
117 |                 TemplateError);
118 |         }
119 |         catch(TemplateError &e)
120 |         {
121 |             CPPUNIT_FAIL((std::string("Got exception: ") + e.what()).c_str());
122 |         }
123 |     }
124 | 
125 |     CPPUNIT_TEST_SUITE(Template_test);
126 |     CPPUNIT_TEST(test_compile);
127 |     CPPUNIT_TEST(test_render);
128 |     CPPUNIT_TEST(test_errors);
129 |     CPPUNIT_TEST(test_missing_var);
130 |     CPPUNIT_TEST_SUITE_END();
131 | 
132 | };
133 | 
134 | CPPUNIT_TEST_SUITE_REGISTRATION(Template_test);
135 | 


--------------------------------------------------------------------------------
/template.cpp:
--------------------------------------------------------------------------------
  1 | #include <cassert>
  2 | #include <fstream>
  3 | #include <sstream>
  4 | #include <unordered_map>
  5 | 
  6 | #include "template.h"
  7 | 
  8 | 
  9 | TemplateError::TemplateError(const std::string &msg)
 10 |   : m_Message(msg)
 11 | {
 12 | }
 13 | 
 14 | TemplateError::~TemplateError() throw()
 15 | {
 16 | }
 17 | 
 18 | const char *TemplateError::what() const throw()
 19 | {
 20 |     return m_Message.c_str();
 21 | }
 22 | 
 23 | 
 24 | void EmptyVariableProvider::handle_variable(std::ostream &out, const std::string &name)
 25 | {
 26 |     throw TemplateError("Missing value for variable " + name);
 27 | }
 28 | 
 29 | 
 30 | static void raise_error(const std::string &filename, int pos,
 31 |                         const std::string &error)
 32 | {
 33 |     std::ostringstream msg;
 34 |     msg << "Error in " << filename << " character " << pos
 35 |         << ": " << error;
 36 |     throw TemplateError(msg.str());
 37 | }
 38 | 
 39 | 
 40 | Template::Template(const std::string &filename)
 41 | {
 42 |     std::ifstream source(filename, std::ios::in | std::ios::binary);
 43 |     if(source.bad())
 44 |         throw TemplateError("Can't open file: " + filename);
 45 |     compile(source, filename);
 46 | }
 47 | 
 48 | Template::Template(std::istream &source, const std::string &filename)
 49 | {
 50 |     compile(source, filename);
 51 | }
 52 | 
 53 | void Template::compile(std::istream &source, const std::string &filename)
 54 | {
 55 |     std::string current;
 56 |     enum {
 57 |         NORMAL,
 58 |         OPEN_1,
 59 |         OPEN_2,
 60 |         VARNAME,
 61 |         CLOSE_1,
 62 |         CLOSE_2
 63 |     } state = NORMAL;
 64 |     std::istreambuf_iterator<char> i(source), e;
 65 |     size_t pos = 0;
 66 |     for(; i != e; ++i, ++pos)
 67 |     {
 68 |         char c = *i;
 69 |         switch(state)
 70 |         {
 71 |         case NORMAL:
 72 |             if(c == '{')
 73 |                 state = OPEN_1;
 74 |             else
 75 |                 current += c;
 76 |             break;
 77 |         case OPEN_1:
 78 |             if(c == '{')
 79 |                 state = OPEN_2;
 80 |             else
 81 |             {
 82 |                 current += '{';
 83 |                 state = NORMAL;
 84 |                 current += c;
 85 |             }
 86 |             break;
 87 |         case OPEN_2:
 88 |             if(!is_space(c))
 89 |             {
 90 |                 m_Blocks.push_back(Block(DATA, current));
 91 |                 current = c;
 92 |                 state = VARNAME;
 93 |             }
 94 |             break;
 95 |         case VARNAME:
 96 |             if(is_space(c))
 97 |                 state = CLOSE_1;
 98 |             else if(c == '}')
 99 |                 state = CLOSE_2;
100 |             else
101 |             {
102 |                 current += c;
103 |                 break;
104 |             }
105 |             assert(state != VARNAME);
106 |             m_Blocks.push_back(Block(VARIABLE, current));
107 |             current.clear();
108 |             break;
109 |         case CLOSE_1:
110 |             if(c == '}')
111 |                 state = CLOSE_2;
112 |             else if(!is_space(c))
113 |                 raise_error(filename, pos, "expecting }");
114 |             break;
115 |         case CLOSE_2:
116 |             if(c == '}')
117 |                 state = NORMAL;
118 |             else
119 |                 raise_error(filename, pos, "expecting }");
120 |             break;
121 |         }
122 |     }
123 |     if(state == OPEN_1)
124 |     {
125 |         current += '{';
126 |         state = NORMAL;
127 |     }
128 |     else if(state != NORMAL)
129 |         raise_error(filename, pos, "premature end of stream");
130 | 
131 |     if(!current.empty())
132 |         m_Blocks.push_back(Block(DATA, current));
133 | }
134 | 
135 | Template::~Template()
136 | {
137 | }
138 | 
139 | bool Template::is_space(char c)
140 | {
141 |     return c == ' ' || c == '\t' || c == '\n';
142 | }
143 | 
144 | void Template::render(std::ostream &out, VariableProvider &vars)
145 | {
146 |     for(const Block &block : m_Blocks)
147 |     {
148 |         switch(block.first)
149 |         {
150 |         case DATA:
151 |             out << block.second;
152 |             break;
153 |         case VARIABLE:
154 |             vars.handle_variable(out, block.second);
155 |             break;
156 |         }
157 |     }
158 | }
159 | 
160 | void Template::render(std::ostream &out,
161 |                       std::initializer_list<const char*> vars)
162 | {
163 |     std::unordered_map<std::string, std::string> map;
164 |     assert(vars.size() % 2 == 0);
165 |     auto iter = vars.begin();
166 |     while(iter != vars.end())
167 |     {
168 |         const char *key = *iter++;
169 |         map[key] = *iter++;
170 |     }
171 |     render(out, map);
172 | }
173 | 


--------------------------------------------------------------------------------
/database.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <unistd.h>
  4 | 
  5 | #include "database.h"
  6 | 
  7 | 
  8 | #define check(r) if((r) != SQLITE_OK) { goto sqlerror; }
  9 | 
 10 | 
 11 | DatabaseError::DatabaseError(const std::string &msg)
 12 |   : m_Message(msg)
 13 | {
 14 | }
 15 | 
 16 | DatabaseError::~DatabaseError() throw()
 17 | {
 18 | }
 19 | 
 20 | const char *DatabaseError::what() const throw()
 21 | {
 22 |     return m_Message.c_str();
 23 | }
 24 | 
 25 | 
 26 | Database::Database(const char *filepath, Generator &generator)
 27 |         throw(DatabaseError)
 28 |   : m_Generator(generator)
 29 | {
 30 |     if(sqlite3_open(filepath, &m_DB) != SQLITE_OK)
 31 |         throw DatabaseError(std::string("Can't open ") + filepath);
 32 |     sqlite3_busy_timeout(m_DB, 50);
 33 | 
 34 |     // Checks whether the database is already setup
 35 |     bool database_setup = false;
 36 |     if(sqlite3_prepare_v2(m_DB, "SELECT state FROM generator_state;",
 37 |                           -1, &m_stmtGetState, NULL) == SQLITE_OK)
 38 |     {
 39 |         int ret = sqlite3_step(m_stmtGetState);
 40 |         if(ret == SQLITE_ROW)
 41 |         {
 42 |             sqlite3_int64 state = sqlite3_column_int(m_stmtGetState, 0);
 43 |             database_setup = true;
 44 |             std::cerr << "Database initialized, generator state: " << state
 45 |                       << std::endl;
 46 |             ret = sqlite3_step(m_stmtGetState);
 47 |         }
 48 |         if(ret != SQLITE_DONE)
 49 |             goto sqlerror;
 50 |         sqlite3_reset(m_stmtGetState);
 51 |     }
 52 | 
 53 |     if(!database_setup)
 54 |     {
 55 |         // Creates the tables
 56 |         const char *sql[] = {
 57 |             "CREATE TABLE generator_state("
 58 |             "    state INTEGER NOT NULL"
 59 |             "    );",
 60 |             "CREATE TABLE urls("
 61 |             "    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
 62 |             "    our_url TEXT NOT NULL,"
 63 |             "    target_url TEXT NOT NULL,"
 64 |             "    author_ip TEXT NULL,"
 65 |             "    author_date TEXT NOT NULL,"
 66 |             "    views INTEGER NOT NULL"
 67 |             "    );",
 68 |             "CREATE INDEX urls_our_url_idx ON urls(our_url);",
 69 |             "INSERT INTO generator_state(state) VALUES(0);"
 70 |         };
 71 |         for(const char *sql_line : sql)
 72 |             check(sqlite3_exec(m_DB, sql_line, NULL, NULL, NULL));
 73 |         std::cerr << "Database created, generator state: 0" << std::endl;
 74 |     }
 75 | 
 76 |     if(!database_setup)
 77 |         check(sqlite3_prepare_v2(m_DB, "SELECT state FROM generator_state;",
 78 |                                  -1, &m_stmtGetState, NULL));
 79 |     check(sqlite3_prepare_v2(
 80 |             m_DB,
 81 |             "UPDATE generator_state SET state=?;",
 82 |             -1, &m_stmtSetState, NULL));
 83 |     check(sqlite3_prepare_v2(
 84 |             m_DB,
 85 |             "INSERT INTO urls(our_url, target_url, "
 86 |                              "author_ip, author_date, views) "
 87 |             "VALUES(?, ?, ?, datetime(), 0);",
 88 |             -1, &m_stmtInsertURL, NULL));
 89 |     check(sqlite3_prepare_v2(
 90 |             m_DB,
 91 |             "SELECT target_url FROM urls WHERE our_url=?;",
 92 |             -1, &m_stmtGetURL, NULL));
 93 |     check(sqlite3_prepare_v2(
 94 |             m_DB,
 95 |             "UPDATE urls SET views=views+1 WHERE our_url=?;",
 96 |             -1, &m_stmtIncrementURLViews, NULL));
 97 |     check(sqlite3_prepare_v2(
 98 |             m_DB,
 99 |             "SELECT views FROM urls WHERE our_url=?;",
100 |             -1, &m_stmtGetViews, NULL));
101 |     check(sqlite3_prepare_v2(
102 |             m_DB,
103 |             "BEGIN IMMEDIATE;",
104 |             -1, &m_stmtBegin, NULL));
105 |     check(sqlite3_prepare_v2(
106 |             m_DB,
107 |             "COMMIT;",
108 |             -1, &m_stmtCommit, NULL));
109 |     check(sqlite3_prepare_v2(
110 |             m_DB,
111 |             "ROLLBACK;",
112 |             -1, &m_stmtRollback, NULL));
113 | 
114 |     return;
115 | 
116 | sqlerror:
117 |     throw DatabaseError("Couldn't initialize database");
118 | }
119 | 
120 | Database::~Database()
121 | {
122 |     sqlite3_finalize(m_stmtGetState);
123 |     sqlite3_finalize(m_stmtSetState);
124 |     sqlite3_finalize(m_stmtInsertURL);
125 |     sqlite3_finalize(m_stmtGetURL);
126 |     sqlite3_finalize(m_stmtIncrementURLViews);
127 |     sqlite3_finalize(m_stmtGetViews);
128 |     sqlite3_finalize(m_stmtBegin);
129 |     sqlite3_finalize(m_stmtCommit);
130 |     sqlite3_finalize(m_stmtRollback);
131 |     sqlite3_close(m_DB);
132 | }
133 | 
134 | void Database::storeURL(const std::string &our_url,
135 |                         const std::string &their_url,
136 |                         const std::string &their_address) throw(DatabaseError)
137 | {
138 |     check(sqlite3_bind_text(m_stmtInsertURL, 1,
139 |                             our_url.c_str(), our_url.size(),
140 |                             SQLITE_TRANSIENT));
141 |     check(sqlite3_bind_text(m_stmtInsertURL, 2,
142 |                             their_url.c_str(), their_url.size(),
143 |                             SQLITE_TRANSIENT));
144 |     check(sqlite3_bind_text(m_stmtInsertURL, 3,
145 |                             their_address.c_str(), their_address.size(),
146 |                             SQLITE_TRANSIENT));
147 | 
148 |     if(sqlite3_step(m_stmtInsertURL) != SQLITE_DONE)
149 |         goto sqlerror;
150 |     sqlite3_reset(m_stmtInsertURL);
151 |     return;
152 | 
153 | sqlerror:
154 |     throw DatabaseError("Couldn't insert a URL");
155 | }
156 | 
157 | void Database::incrementViews(const std::string &our_url) throw(DatabaseError)
158 | {
159 |     check(sqlite3_bind_text(m_stmtIncrementURLViews, 1,
160 |                             our_url.c_str(), our_url.size(),
161 |                             SQLITE_TRANSIENT));
162 | 
163 |     if(sqlite3_step(m_stmtIncrementURLViews) == SQLITE_DONE)
164 |     {
165 |         sqlite3_reset(m_stmtIncrementURLViews);
166 |         return;
167 |     }
168 | 
169 | sqlerror:
170 |     throw DatabaseError("Couldn't increment a URL's view count");
171 | }
172 | 
173 | std::string Database::resolveURL(const std::string &our_url,
174 |                                  bool increment_views) throw(DatabaseError)
175 | {
176 |     int ret;
177 |     check(sqlite3_bind_text(m_stmtGetURL, 1,
178 |                             our_url.c_str(), our_url.size(),
179 |                             SQLITE_TRANSIENT));
180 | 
181 |     ret = sqlite3_step(m_stmtGetURL);
182 |     if(ret == SQLITE_DONE)
183 |     {
184 |         sqlite3_reset(m_stmtGetURL);
185 |         return "";
186 |     }
187 |     else if(ret == SQLITE_ROW)
188 |     {
189 |         std::string result((const char*)sqlite3_column_text(m_stmtGetURL, 0),
190 |                            sqlite3_column_bytes(m_stmtGetURL, 0));
191 |         sqlite3_reset(m_stmtGetURL);
192 |         if(increment_views)
193 |             incrementViews(our_url);
194 |         return result;
195 |     }
196 | 
197 | sqlerror:
198 |     throw DatabaseError("Couldn't resolve a URL");
199 | }
200 | 
201 | unsigned int Database::getViews(const std::string &our_url)
202 |         throw(DatabaseError)
203 | {
204 |     int ret;
205 |     check(sqlite3_bind_text(m_stmtGetViews, 1,
206 |                             our_url.c_str(), our_url.size(),
207 |                             SQLITE_TRANSIENT));
208 | 
209 |     ret = sqlite3_step(m_stmtGetViews);
210 |     if(ret == SQLITE_DONE)
211 |     {
212 |         sqlite3_reset(m_stmtGetViews);
213 |         return 0;
214 |     }
215 |     else if(ret == SQLITE_ROW)
216 |     {
217 |         unsigned int result = sqlite3_column_int(m_stmtGetViews, 0);
218 |         sqlite3_reset(m_stmtGetViews);
219 |         return result;
220 |     }
221 | 
222 | sqlerror:
223 |     throw DatabaseError("Couldn't get a URL's' view count");
224 | }
225 | 
226 | sqlite3_int64 Database::getState() throw(DatabaseError)
227 | {
228 |     if(sqlite3_step(m_stmtGetState) == SQLITE_ROW)
229 |     {
230 |         sqlite3_int64 result = sqlite3_column_int64(m_stmtGetState, 0);
231 |         if(sqlite3_step(m_stmtGetState) != SQLITE_DONE)
232 |             goto sqlerror;
233 |         sqlite3_reset(m_stmtGetState);
234 |         return result;
235 |     }
236 | 
237 | sqlerror:
238 |     throw DatabaseError("Couldn't get the generator state");
239 | }
240 | 
241 | void Database::setState(sqlite3_int64 state) throw(DatabaseError)
242 | {
243 |     check(sqlite3_bind_int64(m_stmtSetState, 1, state));
244 |     if(sqlite3_step(m_stmtSetState) != SQLITE_DONE)
245 |         goto sqlerror;
246 |     sqlite3_reset(m_stmtSetState);
247 |     return;
248 | 
249 | sqlerror:
250 |     throw DatabaseError("Couldn't set the generator state");
251 | }
252 | 
253 | Key Database::nextState() throw(DatabaseError)
254 | {
255 |     for(int wait = 0; wait <= 20; wait += 5)
256 |     {
257 |         if(wait > 0)
258 |             usleep(wait * 1000);
259 |         switch(sqlite3_step(m_stmtBegin))
260 |         {
261 |         case SQLITE_BUSY:
262 |             check(sqlite3_reset(m_stmtBegin));
263 |             continue;
264 |         case SQLITE_DONE:
265 |             check(sqlite3_reset(m_stmtBegin));
266 |             break;
267 |         default:
268 |             goto sqlerror;
269 |         }
270 | 
271 |         Key state = getState();
272 |         state = m_Generator.generate(state);
273 | 
274 |         check(sqlite3_bind_int64(m_stmtSetState, 1, state));
275 |         int ret = sqlite3_step(m_stmtSetState);
276 |         check(sqlite3_reset(m_stmtSetState));
277 |         if(ret == SQLITE_DONE)
278 |         {
279 |             ret = sqlite3_step(m_stmtCommit);
280 |             check(sqlite3_reset(m_stmtCommit));
281 |         }
282 |         switch(ret)
283 |         {
284 |         case SQLITE_DONE:
285 |             return state;
286 |         case SQLITE_BUSY:
287 |             if(sqlite3_step(m_stmtRollback) != SQLITE_DONE)
288 |                 goto sqlerror;
289 |             check(sqlite3_reset(m_stmtRollback));
290 |             continue;
291 |         default:
292 |             goto sqlerror;
293 |         }
294 |     }
295 | 
296 | sqlerror:
297 |     throw DatabaseError("Couldn't advance the generator state");
298 | }
299 | 


--------------------------------------------------------------------------------
/cgi.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdio>
  2 | #ifdef _WIN32
  3 | #include <process.h>
  4 | #else
  5 | #include <unistd.h>
  6 | extern char **environ;
  7 | #endif
  8 | #include <cstdlib>
  9 | #include <fcgio.h>
 10 | 
 11 | #include "database.h"
 12 | #include "insults.h"
 13 | #include "template.h"
 14 | 
 15 | 
 16 | static bool startswith(const std::string &str, const std::string &prefix)
 17 | {
 18 |     return str.compare(0, prefix.length(), prefix) == 0;
 19 | }
 20 | 
 21 | 
 22 | static int base16_decode(char e)
 23 | {
 24 |     if(e >= '0' && e <= '9')
 25 |         return (unsigned char)(e - '0');
 26 |     else if(e >= 'a' && e <= 'f')
 27 |         return (unsigned char)(e - 'a' + 10);
 28 |     else if(e >= 'A' && e <= 'F')
 29 |         return (unsigned char)(e - 'A' + 10);
 30 |     else
 31 |         return -1;
 32 | }
 33 | 
 34 | 
 35 | class URLValidator {
 36 | 
 37 | private:
 38 |     unsigned char m_Table[256];
 39 | 
 40 | public:
 41 |     static const char *const ALLOWED_CHARS;
 42 | 
 43 |     URLValidator();
 44 |     bool operator()(const std::string &url);
 45 | 
 46 | } valid_url;
 47 | 
 48 | const char *const URLValidator::ALLOWED_CHARS =
 49 |     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 50 |     "abcdefghijklmnopqrstuvwxyz"
 51 |     "0123456789"
 52 |     "-._~:/?#[]@!$&'()*+,;="
 53 |     "%";
 54 | 
 55 | URLValidator::URLValidator()
 56 | {
 57 |     for(size_t i = 0; i <= 255; ++i)
 58 |         m_Table[i] = 0;
 59 |     for(const char *c = ALLOWED_CHARS; *c != 0; ++c)
 60 |         m_Table[(size_t)(unsigned char)*c] = 1;
 61 | }
 62 | 
 63 | bool URLValidator::operator()(const std::string &url)
 64 | {
 65 |     if(!startswith(url, "http://") && !startswith(url, "https://") &&
 66 |        !startswith(url, "ftp://"))
 67 |         return false;
 68 |     for(size_t i = 0; i < url.size(); ++i)
 69 |     {
 70 |         const unsigned char c = url[i];
 71 |         if(!m_Table[(size_t)c])
 72 |             return false;
 73 |     }
 74 |     return true;
 75 | }
 76 | 
 77 | 
 78 | static std::string get_var(const std::string &formdata,
 79 |                            const std::string &var)
 80 | {
 81 |     std::string buffer;
 82 |     enum EState { VARNAME, VALUE, WRONGVALUE };
 83 |     EState state = VARNAME;
 84 |     for(size_t i = 0; i < formdata.size(); ++i)
 85 |     {
 86 |         switch(state)
 87 |         {
 88 |         case VARNAME:
 89 |             if(formdata[i] == '=')
 90 |             {
 91 |                 if(buffer == var)
 92 |                     state = VALUE;
 93 |                 else
 94 |                     state = WRONGVALUE;
 95 |                 buffer = "";
 96 |             }
 97 |             else
 98 |                 buffer += formdata[i];
 99 |             break;
100 |         case VALUE:
101 |             if(formdata[i] == '&')
102 |                 return buffer;
103 |             else if(formdata[i] == '+')
104 |                 buffer += ' ';
105 |             else if(formdata[i] == '%')
106 |             {
107 |                 if(i + 2 >= formdata.size())
108 |                 {
109 |                     buffer += formdata.substr(i);
110 |                     i = formdata.size();
111 |                 }
112 |                 else
113 |                 {
114 |                     int char1 = base16_decode(formdata[i+1]);
115 |                     int char2 = base16_decode(formdata[i+2]);
116 |                     if(char1 < 0 || char2 < 0)
117 |                         buffer += formdata.substr(i, 3);
118 |                     else
119 |                         buffer += (char)((char1 << 4) | char2);
120 |                     i += 2;
121 |                 }
122 |             }
123 |             else
124 |                 buffer += formdata[i];
125 |             break;
126 |         case WRONGVALUE:
127 |             if(formdata[i] == '&')
128 |                 state = VARNAME;
129 |             break;
130 |         }
131 |     }
132 |     if(state == VALUE)
133 |         return buffer;
134 |     return "";
135 | }
136 | 
137 | 
138 | // Maximum number of bytes allowed to be read from stdin
139 | static const unsigned long REQ_IN_MAX = 10000;
140 | 
141 | static std::string get_req(FCGX_Request *request,
142 |                     std::istream &req_in, std::ostream &req_err)
143 | {
144 |     char *clenstr = FCGX_GetParam("CONTENT_LENGTH", request->envp);
145 |     unsigned long clen = REQ_IN_MAX;
146 |     std::string content;
147 | 
148 |     if(clenstr)
149 |     {
150 |         clen = std::strtol(clenstr, &clenstr, 10);
151 |         if(*clenstr)
152 |         {
153 |             req_err << "can't parse \"CONTENT_LENGTH="
154 |                     << FCGX_GetParam("CONTENT_LENGTH", request->envp)
155 |                     << "\"\n";
156 |             clen = REQ_IN_MAX;
157 |         }
158 |         // *always* put a cap on the amount of data that will be read
159 |         else if(clen > REQ_IN_MAX)
160 |             clen = REQ_IN_MAX;
161 | 
162 |         content.resize(clen);
163 | 
164 |         req_in.read(&content[0], clen);
165 |         clen = req_in.gcount();
166 |     }
167 |     else
168 |     {
169 |         // *never* read req_in when CONTENT_LENGTH is missing or unparsable
170 |         clen = 0;
171 |     }
172 | 
173 |     // Chew up any remaining req_in - this shouldn't be necessary
174 |     // but is because mod_fastcgi doesn't handle it correctly.
175 | 
176 |     // ignore() doesn't set the eof bit in some versions of glibc++
177 |     // so use gcount() instead of eof()...
178 |     do
179 |         req_in.ignore(1024);
180 |     while(req_in.gcount() == 1024);
181 | 
182 |     return content;
183 | }
184 | 
185 | 
186 | int main()
187 | {
188 |     const char *db_path = getenv("DATABASE_PATH");
189 |     if(!db_path || db_path[0] == 0)
190 |         return 1;
191 |     std::string tpl_path;
192 |     {
193 |         const char *tpl_path_ = getenv("TEMPLATES_PATH");
194 |         if(!tpl_path_ || tpl_path_[0] == 0)
195 |             return 1;
196 |         tpl_path = tpl_path_;
197 |     }
198 | 
199 |     Template index(tpl_path + "/index.html");
200 |     Template error(tpl_path + "/error.html");
201 |     Template created(tpl_path + "/created.html");
202 | 
203 |     Insults insults;
204 |     Generator gen(insults.CHOICES);
205 |     Database db(db_path, gen);
206 | 
207 | 
208 |     FCGX_Request request;
209 | 
210 |     FCGX_Init();
211 |     FCGX_InitRequest(&request, 0, 0);
212 | 
213 |     while(FCGX_Accept_r(&request) == 0)
214 |     {
215 |         // Note that the default bufsize (0) will cause the use of iostream
216 |         // methods that require positioning (such as peek(), seek(),
217 |         // unget() and putback()) to fail (in favour of more efficient IO).
218 |         fcgi_streambuf in_fcgi_streambuf(request.in);
219 |         fcgi_streambuf out_fcgi_streambuf(request.out);
220 |         fcgi_streambuf err_fcgi_streambuf(request.err);
221 | 
222 |         std::istream req_in(&in_fcgi_streambuf);
223 |         std::ostream req_out(&out_fcgi_streambuf);
224 |         std::ostream req_err(&err_fcgi_streambuf);
225 | 
226 |         // Although FastCGI supports writing before reading,
227 |         // many http clients (browsers) don't support it (so
228 |         // the connection deadlocks until a timeout expires!).
229 |         std::string content = get_req(&request, req_in, req_err);
230 | 
231 |         // Gets method and path from environment
232 |         std::string method, uri, host, remote_addr;
233 |         {
234 |             const char *const *envp = request.envp;
235 |             for(; *envp; ++envp)
236 |             {
237 |                 if(startswith(*envp, "REQUEST_URI="))
238 |                     uri = (*envp) + 12;
239 |                 else if(startswith(*envp, "REQUEST_METHOD="))
240 |                     method = (*envp) + 15;
241 |                 else if(startswith(*envp, "HTTP_HOST="))
242 |                     host = (*envp) + 10;
243 |                 else if(startswith(*envp, "REMOTE_ADDR="))
244 |                     remote_addr = (*envp) + 12;
245 |             }
246 |         }
247 | 
248 |         if(startswith(host, "localhost") ||
249 |            startswith(host, "127.") ||
250 |            startswith(host, "www.clique-salope.ovh") ||
251 |            startswith(host, "clique-salope.ovh"))
252 |         {
253 |             if(method == "GET" && uri == "/")
254 |             {
255 |                 req_out << "Server: insurlt\r\n"
256 |                            "Content-type: text/html; charset=utf-8\r\n"
257 |                            "\r\n";
258 |                 index.render(req_out);
259 |             }
260 |             else if(method == "POST" && uri == "/")
261 |             {
262 |                 std::string their_url = get_var(content, "url");
263 |                 if(their_url.empty() || !valid_url(their_url))
264 |                 {
265 |                     req_out << "Status: 404 Not Found\r\n"
266 |                                "Server: insurlt\r\n"
267 |                                "Content-type: text/html; charset=utf-8\r\n"
268 |                                "\r\n";
269 |                     error.render(req_out, {
270 |                             "message",
271 |                             "T'as oubli\xC3\xA9 l'URL, face de pet ?"});
272 |                 }
273 |                 else
274 |                 {
275 |                     Key new_key = db.nextState();
276 |                     std::string our_url = insults.generate(new_key);
277 |                     db.storeURL(our_url, their_url, remote_addr);
278 | 
279 |                     req_out << "Status: 303 See Other\r\n"
280 |                                "Server: insurlt\r\n"
281 |                                "Location: /created?" << new_key << "\r\n"
282 |                                "Content-type: text/plain\r\n"
283 |                                "\r\n"
284 |                                "http://" << our_url << "/\n";
285 |                 }
286 |             }
287 |             else if(startswith(uri, "/created?"))
288 |             {
289 |                 char *endptr;
290 |                 Key key = std::strtol(uri.c_str() + 9, &endptr, 10);
291 |                 if(*endptr)
292 |                 {
293 |                     req_out << "Status: 404 Not Found\r\n"
294 |                                "Server: insurlt\r\n"
295 |                                "Content-type: text/html; charset=utf-8\r\n"
296 |                                "\r\n";
297 |                     error.render(req_out, {
298 |                             "message",
299 |                             "Il manque un num\xC3\xA9ro, b\xC3\xA2tard"});
300 |                 }
301 |                 else
302 |                 {
303 |                     std::string our_url = insults.generate(key);
304 | 
305 |                     req_out << "Server: insurlt\r\n"
306 |                                "Content-type: text/html; charset=utf-8\r\n"
307 |                                "\r\n";
308 |                     created.render(req_out, {
309 |                             "url", ("http://" + our_url + "/").c_str()});
310 |                 }
311 |             }
312 |             else
313 |             {
314 |                 req_out << "Status: 404 Not Found\r\n"
315 |                            "Server: insurlt\r\n"
316 |                            "Content-type: text/html; charset=utf-8\r\n"
317 |                            "\r\n";
318 |                 error.render(req_out, {
319 |                         "message",
320 |                         "Il n'y a rien ici. T'es perdu, grosse merde ?"});
321 |             }
322 |         }
323 |         else
324 |         {
325 |             std::string our_url = host;
326 |             size_t end = our_url.find_first_of(":/");
327 |             if(end != std::string::npos)
328 |                 our_url = our_url.substr(0, end);
329 |             std::string their_url = db.resolveURL(our_url, true);
330 |             if(their_url.empty())
331 |             {
332 |                 req_out << "Status: 404 Not Found\r\n"
333 |                            "Server: insurlt\r\n"
334 |                            "Content-type: text/html; charset=utf-8\r\n"
335 |                            "\r\n";
336 |                 error.render(req_out, {
337 |                         "message",
338 |                         "Il n'y a rien ici. T'es perdu, grosse merde ?"});
339 |             }
340 |             else
341 |             {
342 |                 req_out << "Status: 301 Moved Permanently\r\n"
343 |                            "Server: insurlt\r\n"
344 |                            "Location: " << their_url << "\r\n"
345 |                            "Content-type: text/plain\r\n"
346 |                            "\r\n"
347 |                         << their_url << "\n";
348 |             }
349 |         }
350 | 
351 |         // If the output streambufs had non-zero bufsizes and
352 |         // were constructed outside of the accept loop (i.e.
353 |         // their destructor won't be called here), they would
354 |         // have to be flushed here.
355 |     }
356 | 
357 |     return 0;
358 | }
359 | 


--------------------------------------------------------------------------------