import subprocess

import configparser

import re

import json

import requests

from ast import literal_eval

OBFS_REGEX = re.compule(r'^ServerTransportPlugin obfs2,obfs3')

IP_REGEX = re.compile((r'^(OutboundBindAddress)'

                       r' (\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3})'))

def read_tor_config(configfile="/etc/tor/torrc"):

    with open(configfile) as fb:

        lines = {line[:-1] for line in fb if not line.startswith('#')}

    lines = {line for line in filter(None, lines)}

    return lines

def get_tor_status(name='tor'):

    try:

        pids = subprocess.check_output(['pidof', 'tor']).decode('utf-8')

        pids = pids.split(' ')

        pid_file = '.'.join([name, 'pid'])

        pid = open('/'.join(['var', 'run', name, pid_file])).readline()

        if pid in pids:

            return "Online"

        else:

            return "Offline"

    except subprocess.CalledProcessError:

        return "Offline"

def get_tor_fingerprint(name='tor'):

    fingerprint_file = '/'.join(['var', 'lib', name, 'fingerprint'])

    with open(fingerprint_file) as fb:

        line = fb.readline()[:-1]

    hostname, fingerprint = line.split(' ')

    return hostname, fingerprint

def get_server_type(tor_config):

    if 'BridgeRelay 1' in tor_config:

        if any(OBFS_REGEX.match(i) for i in tor_config):

            return 'Bridge', 'True'

        else:

            return 'Bridge', 'False'

    elif 'ExitPolicy reject *:*' in tor_config:

        return 'Relay', None

    else:

        return 'Exit', None

def get_ip(tor_config):

    for i in tor_config:

        match = IP_REGEX.match(i)

        if match:

            return i.groups()[1]

        else:

            return None

def get_config():

    config = configparser.ConfigParser()

    config.read('/etc/ennstatus_updater.conf')

    return config

def create_server_json(tor_configfile='/etc/tor/torrc', name='tor'):

    tor_config = read_tor_config(tor_configfile)

    server_type, obfs = get_server_type(tor_config)

    hostname, fingerprint = get_tor_fingerprint(name)

    tor_status = get_tor_status(name)

    ip = get_ip(tor_config)

    dictionary = {'server_type': server_type, 'server_name': hostname,

                  'tor_status': tor_status}

    if ip is not None:

        dictionary['ip'] = ip

    if obfs is not None:

        dictionary['obfs'] = obfs

    if server_type != 'Bridge':

        dictionary['fingerprint'] = fingerprint

    return json.dumps(dictionary)

def update_server(server_json, url):

    response = requests.post(url + '/api/update', data=server_json)

    return response.text

def main():

    config = get_config()

    ennstatus_url = config['main']['ennstatus_url']

    if 'servers' in config['main']:

        for server in literal_eval(config['main']['servers']):

            server_json = create_server_json(config[server]['configfile'],

                                             server)

            response = update_server(server_json, ennstatus_url)

    else:

        server_json = create_server_json()

        response = update_server(server_json, ennstatus_url)

    print(response)

Sphinx==1.1.3

sphinx-intl==0.9.3

Flask-Script==0.6.2

ipython==1.1.0

pip-tools==1.0

distribute==0.7.3

docutils==0.11

Flask-Script==0.6.2

ipython==1.1.0

pip-tools==0.3.4

polib==1.0.3

Pygments==1.6

six==1.4.1

sphinx-intl==0.9.3

Sphinx==1.1.3

from flask import Flask

from flask_bootstrap import Bootstrap

from flask.ext.compress import Compress

from flask_sslify import SSLify

from ennstatus.log import init_logging

app = Flask(__name__)

app.config.from_object('config')

Bootstrap(app)

Compress(app)

SSLify(app, permanent=True)

from ennstatus.views import root_page

from ennstatus.api.views import api_page

from ennstatus.donate.views import donate_page

from ennstatus.status.views import status_page

app.register_blueprint(root_page)

app.register_blueprint(api_page, url_prefix='/api')

app.register_blueprint(donate_page, url_prefix='/donate')

app.register_blueprint(status_page, url_prefix='/status')

init_logging(app)

application = app

import re

import json

from datetime import datetime

from ast import literal_eval

import pygeoip

FINGERPRINT_REGEX = re.compile(r'^[A-Z0-9]{40}$', re.I)

IP_REGEX = (r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}'

            r'(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$')

IP_REGEX = re.compile(IP_REGEX)

PRIVATE_IP_REGEX = (r'(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)'

                    r'|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|'

                    r'255\.255\.255\.255')

PRIVATE_IP_REGEX = re.compile(PRIVATE_IP_REGEX)

DATE_FORMAT = '%d-%m-%Y %H:%M:%S'

gi4 = pygeoip.GeoIP('/usr/share/GeoIP/GeoIP.dat', pygeoip.MEMORY_CACHE)

def check_json_format(server):

    for key in ('server_type', 'server_name', 'tor_status'):

        if not key in server:

            raise ValueError('%s key not present!\n' % key)

    if not server['server_type'] in ('Exit', 'Relay', 'Bridge'):

        error_message = ('server_type has not the right content!'

                         ' is: %s must be one of: Exit, Relay or Bridge\n') \

            % server['server_type']

        raise ValueError(error_message)

    if not server['tor_status'] in ('Online', 'Offline'):

        error_message = ('tor_status has not the right content!'

                         ' is: %s must be one of: Online or Offline\n') \

            % server['tor_status']

    if server['server_type'] in ('Exit', 'Relay'):

        if not 'fingerprint' in server:

            raise ValueError('fingerprint key not present!\n')

        else:

            if FINGERPRINT_REGEX.match(server['fingerprint']) is None:

                raise ValueError('fingerprint has not the right format!\n')

    else:

        if 'obfs' not in server:

            raise ValueError('obfs key not present!\n')

        else:

            if server['obfs'] not in ('True', 'False'):

                error_message = ('obfs has not the right content!'

                                 ' is: %s must be one of: True or False\n') \

                    % server['obfs']

                raise ValueError(error_message)

    if 'ip' in server:

        if IP_REGEX.match(server['ip']) is None:

            raise ValueError('ip is not the right format!\n')

        elif PRIVATE_IP_REGEX.match(server['ip']) is not None:

            raise ValueError('ip is not accepted!\n')

    return True

def update_server(server, ip):

    server['last_updated'] = datetime.utcnow().strftime(DATE_FORMAT)

    server['server_status'] = 'Online'

    server['country'] = gi4.country_name_by_addr(ip)

    if server['server_type'] == 'Bridge':

        server['obfs'] = literal_eval(server['obfs'])

        for key in ('fingerprint', 'ip'):

            if key in server:

                del server[key]

    else:

        if 'obfs' in server:

            del server['obfs']

        server['ip'] = ip

    try:

        filename = ''.join(['data/', server['server_name'].lower(), '.json'])

        with open(filename, 'w') as fb:

            json.dump(server, fb)

        return server

    except Exception as e:

        return e

from flask import (Blueprint, request, current_app, jsonify, render_template,

                   abort)

from ennstatus.api.functions import check_json_format, update_server

from ennstatus.status.functions import (single_server, all_servers,

                                        all_servers_by_type)

api_page = Blueprint('api', __name__)

@api_page.route('/update', methods=('POST',))

def update():

    current_app.logger.info('Handling update')

    if current_app.debug:

        accepted_ips = ['127.0.0.1']

    else:

        accepted_ips = current_app.config.get('ENNSTATUS_ACCEPTED_IPS', [])

    json = request.get_json()

    if json is None:

        current_app.logger.info('No JSON data supplied!')

        return 'No JSON data supplied!\n', 400, {'Content-Type': 'text/plain'}

    try:

        check_json_format(json)

    except ValueError as e:

        current_app.logger.warning(' '.join([str(e), str(json)]))

        return str(e), 409, {'Content-Type': 'text/plain'}

    if 'ip' in json:

        ip = json['ip']

    else:

        ip = request.remote_addr

    if request.remote_addr not in accepted_ips:

        current_app.logger.warn("Unallowed IP %s tried to update data!"

                                % ip)

        return 'IP not allowed!\n', 403, {'Content-Type': 'text/plain'}

    server = update_server(server=json, ip=ip)

    if server:

        current_app.logger.info('Return result')

        return (jsonify(server), 201,

                {'Location': '/api/export/json/single?server_name=%s'

                 % server['server_name']})

    else:

        current_app.logger.error("Unexpected error: %s" % server,

                                 exc_info=True)

        return abort(500)

@api_page.route('/export', defaults={'server_type': 'all',

                                     'export_format': 'json'})

@api_page.route('/export/<any("json", "xml"):export_format>',

                defaults={'server_type': 'all'})

@api_page.route(('/export/<any("json", "xml"):export_format>'

                 '/<any("all", "exit", "bridge", "relay", "single")'

                 ':server_type>'))

def export(export_format, server_type):

    current_app.logger.info('Handling export')

    if server_type == 'single':

        server_name = request.args.get('server_name', None)

        if server_name is not None:

            server = single_server(server_name)

            if server:

                if export_format == 'json':

                    current_app.logger.info('Returning server as json!')

                    return jsonify(server)

                else:

                    current_app.logger.info('Returning server as xml!')

                    return (

                        render_template(

                            'api/extract/xml/single_server.xml',

                            server=server),

                        200, {'Content-Type': 'text/xml'})

            else:

                current_app.logger.warning('Server not found!')

                return ('Server not found!\n',

                        404, {'Content-Type': 'text/plain'})

        else:

            current_app.logger.warning('No server_name specified!')

            return ('No server_name specified!\n',

                    400, {'Content-Type': 'text/plain'})

    else:

        if server_type == 'all':

            current_app.logger.info('Getting all servers!')

            servers = list(all_servers())

        else:

            current_app.logger.info('Getting all %s!' % server_type)

            servers = list(all_servers_by_type(server_type.capitalize()))

        if export_format == 'json':

            response = {'enn-network': servers}

            current_app.logger.info('Returning as json!')

            return jsonify(response)

        else:

            current_app.logger.info('Returning as xml!')

            return (render_template('api/extract/xml/network.xml',

                                    servers=servers),

                    200, {'Content-Type': 'text/xml'})

from flask_wtf import Form

from wtforms import SelectField

from wtforms.validators import DataRequired

class DateForm(Form):

    date = SelectField('date', validators=[DataRequired()])

import os

import os.path

import csv

def load_csv(date):

    filename = '.'.join([date, 'csv'])

    path = os.path.join('donations', filename)

    with open(path, newline='') as csvfile:

        csvreader = csv.reader(csvfile, delimiter=',')

        for row in csvreader:

            yield row

def get_choices():

    files = os.listdir('donations')

    for file in files:

        if not file.startswith('.') \

           and file.endswith('.csv'):

            yield os.path.splitext(file)[0]

from flask import (Blueprint, render_template, request,

                   redirect, url_for, current_app)

from ennstatus.donate.forms import DateForm

from ennstatus.donate.functions import load_csv, get_choices

donate_page = Blueprint('donate', __name__)

@donate_page.route('/')

def index():

    return render_template('donate/index.html')

@donate_page.route('/wiretransfer')

def wiretransfer():

    return render_template('donate/wiretransfer.html')

@donate_page.route('/snailmail')

def snailmail():

    return render_template('donate/snailmail.html')

@donate_page.route('/paypal')

def paypal():

    return render_template('donate/paypal.html')

@donate_page.route('/bitcoin')

def bitcoin():

    return render_template('donate/bitcoin.html')

@donate_page.route('/flattr')

def flattr():

    return render_template('donate/flattr.html')

@donate_page.route('/received',

                   methods=('GET', 'POST'))

def received():

    current_app.logger.info('Handling received')

    form = DateForm()

    current_app.logger.debug('Creating choices')

    choices = [name for name in get_choices()]

    choices.sort()

    form.date.choices = [(name, name) for name in choices]

    if not choices:

        current_app.logger.warn('No donations found!')

        return render_template('donate/received.html',

                               form=form, csv_file=None,

                               date=None)

    if request.method == 'POST':

        current_app.logger.debug('Validating form')

        if form.validate_on_submit():

            date = form.date.data

            return redirect(url_for('donate.received', date=date))

    else:

        if 'date' in request.args:

            date = request.args['date']

            if request.args['date'] in choices:

                current_app.logger.info('Showing date %s' % date)

                form.date.data = date

                csv_file = load_csv(date)

            else:

                current_app.logger.warn('Date %s not found' % date)

                return ('Date %s not found!', 500,

                        {'Content-Type': 'text/plain'})

        else:

            current_app.logger.info('Showing last date %s' % choices[-1])

            form.date.data = choices[-1]

            csv_file = load_csv(choices[-1])

            date = choices[-1]

        current_app.logger.info('Return result')

        return render_template('donate/received.html',

                               form=form, csv_file=csv_file,

                               date=date)

import logging

import logging.handlers

logging_debug_string = "%(levelname)s:%(name)s:%(asctime)s:%(filename)s:%(lineno)d: %(message)s"

logging_string = "%(levelname)s - %(name)s - %(asctime)s - %(message)s"

logging_debug_formatter = logging.Formatter(logging_debug_string)

logging_formatter = logging.Formatter(logging_string)

def init_logging(app):

    app.logger.setLevel(logging.DEBUG)

    stream_handler = logging.StreamHandler()

    stream_handler.setLevel(logging.DEBUG)

    stream_handler.setFormatter(logging_debug_formatter)

    rotating_file_handler = logging.handlers.RotatingFileHandler(

        'log/ennstatus.log',

        maxBytes=130000,

        backupCount=10,

        encoding='utf-8')

    rotating_file_handler.setLevel(logging.INFO)

    rotating_file_handler.setFormatter(logging_formatter)

    if app.debug:

        second_rotating_file_handler = logging.handlers.RotatingFileHandler(

            'log/ennstatus_debug.log',

            maxBytes=130000,

            backupCount=20,

            encoding='utf-8')

        second_rotating_file_handler.setLevel(logging.DEBUG)

        second_rotating_file_handler.setFormatter(logging_debug_formatter)

        app.logger.addHandler(second_rotating_file_handler)

    smtp_handler = logging.handlers.SMTPHandler(

        "localhost",

        "info@c3l.lu",

        app.config.get('ENNSTATUS_ADMINS', None),

        "[Ennstatus] Error")

    smtp_handler.setLevel(logging.ERROR)

    smtp_handler.setFormatter(logging_formatter)

    app.logger.addHandler(stream_handler)

    app.logger.addHandler(rotating_file_handler)

blockquote {

    border: none;

}

.thumbnail {

    border: none;

}

.container {

    margin-top:1%;

}

[class^="flag-"],

[class*=" flag-"] {

    display: inline-block;

    width: 16px;

    height: 11px;

    margin-top: 1px;

    *margin-right: .3em;

    line-height: 16px;

    vertical-align: baseline;

    background-repeat: no-repeat;

}

.flag-andorra,

.flag-ad,

.flag-and {

    background-image: url("img/gif/ad.gif");

}

.flag-united-arab-emirates,

.flag-ae,

.flag-are {

    background-image: url("img/gif/ae.gif");

}

.flag-afghanistan,

.flag-af,

.flag-afg {

    background-image: url("img/gif/af.gif");

}

.flag-antigua-and-barbuda,

.flag-ag,

.flag-atg {

    background-image: url("img/gif/ag.gif");

}

.flag-anguilla,

.flag-ai,

.flag-aia {

    background-image: url("img/gif/ai.gif");

}

.flag-albania,

.flag-al,

.flag-alb {

    background-image: url("img/gif/al.gif");

}

.flag-armenia,

.flag-am,

.flag-arm {

    background-image: url("img/gif/am.gif");

}

.flag-angola,

.flag-ao,

.flag-ago {

    background-image: url("img/gif/ao.gif");

}

.flag-antarctica,

.flag-aq,

.flag-ata {

    background-image: url("img/gif/aq.gif");

}