Ejemplo n.º 1
0
def config_by_name(request, address, productID, config_name):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    ldap_info = request.session['ldap'][address]
    (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
        
    return render_to_response('ssim/config/edit.html', {'product':product_instance, 'config':config, 'address':address},
        mimetype="text/html")
Ejemplo n.º 2
0
def config_general(request, address, productID, config_name):
    ldap_connection = utils.get_ldap_connection(request.session, address)

    configDN = request.POST.get('configDN', None)
    config = None;
    if configDN == None:
        ldap_info = request.session['ldap'][address]
        (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
    else:
        config = configuration.get_config_by_dn(ldap_connection, configDN)

    if request.method == 'GET':
        data = {'name':config.name,
                'desc':config.desc,
                'updated_at':config.updated_at,
                'configDN':config.dn
               }
        form = GeneralForm(initial = data)
    else:
        form = GeneralForm(request.POST)
        if form.is_valid():
            # save data
            general.update_config(ldap_connection, config, form)

    return render_to_response('ssim/config/general.html', {
        'productID':productID,
        'config':config,
        'form':form,
        'address':address,
        'action':request.path},
        mimetype="text/html")
Ejemplo n.º 3
0
def locations(request, address):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    ldap_info = request.session['ldap'][address]
    clients = location.all(ldap_connection, ldap_info['domain'])

    return render_to_response('ssim/locations.html', {'clients':clients, 'address':address},
        mimetype="text/html")
Ejemplo n.º 4
0
def config_sensors(request, address, productID, config_name, selected_sensor):
    ldap_connection = utils.get_ldap_connection(request.session, address)

    configDN = request.POST.get('configDN', None)
    config = None;
    if configDN == None:
        ldap_info = request.session['ldap'][address]
        (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
    else:
        config = configuration.get_config_by_dn(ldap_connection, configDN)

    sensor_config = configuration.get_sensor_config(ldap_connection, config)
    sensor_list = sensor.get_all_sensors(sensor_config.data)

    #define selected and first link
    first_sensor = None
    if len(sensor_list) > 0:
        first_sensor = sensor_list[0].name
    # render
    return render_to_response('ssim/config/sensors.html', {
                'productID':productID,
                'config':config,
                'sensor_config': sensor_config,
                'sensors':sensor_list,
                'first_link':first_sensor,
                'selected_link':selected_sensor,
                'address':address,
                },
                mimetype="text/html")
Ejemplo n.º 5
0
def products(request, address, client = None):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    if ldap_connection is None:
        return HttpResponse("Please reconnect to SSIM", mimetype='text/plain')
    ldap_info = request.session['ldap'][address]
    product_list= product.all(ldap_connection, ldap_info['domain'])
    return render_to_response('ssim/products.html', {'products':product_list, 'address':address},
        mimetype="text/html")
Ejemplo n.º 6
0
def index(request, address = None):

    ldap_connection = utils.get_ldap_connection(request.session, address)
    if ldap_connection == None:
        return redirect('symantec.ssim.views.login', address=address)

    return render_to_response('ssim/index.html', {'address':address},
        mimetype="text/html")
Ejemplo n.º 7
0
def client_products(request, address, client = None):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    locationDN = request.POST.get('locationDN', None)
    if locationDN == None:
        ldap_info = request.session['ldap'][address]
        locationDN = location.client_dn(ldap_connection, ldap_info['domain'], client)
    products = product.client_products(ldap_connection, locationDN)
    return render_to_response('ssim/client_products.html', {'products':products, 'address':address},
        mimetype="text/html")
Ejemplo n.º 8
0
def create_config(request, address, productID, config_name):
    try:
        ldap_connection = utils.get_ldap_connection(request.session, address)
        ldap_info = request.session['ldap'][address]
        new_config_name = config_name.encode("utf-8")
        result = configuration.copy_dafault_config(ldap_connection, ldap_info['domain'], productID, new_config_name)
    except Exception as ex:
        return config_by_product_id(request, address, productID, ex)

    return config_by_product_id(request, address, productID)
Ejemplo n.º 9
0
def test_ldap(request):
    # Serialize the result of the database retrieval to JSON and send an application/json response
    try:
        data = utils.get_ldap_connection(request);
    except ldap.INVALID_CREDENTIALS:
        data = "Your username or password is incorrect."
    except ldap.LDAPError as ex:
        data = "LDAP error type \"%s\". Arguments \"%s\". Message: %s" % (type(ex), ex.args, ex)
    return HttpResponse(data,
            mimetype='text/plain')
Ejemplo n.º 10
0
def get_archives(request, address):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    ldap_info = request.session['ldap'][address]

    archives = archive_getter.get_archives(ldap_connection, ldap_info['domain'])

    return render_to_response('ssim/events/archive_selector.html',
        {
            'address':address,
            'archives':archives,
        },
        mimetype="text/html")
Ejemplo n.º 11
0
def get_query_groups(request, address):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    ldap_info = request.session['ldap'][address]

    query_groups = queries.get_query_groups(ldap_connection, ldap_info['domain'])
    system_query_groups = queries.get_system_query_groups(ldap_connection, ldap_info['domain'])

    return render_to_response('ssim/events/query_groups.html',
        {
            'address':address,
            'query_groups':query_groups,
            'system_query_groups':system_query_groups,
        },
        mimetype="text/html")
Ejemplo n.º 12
0
def config_sensor(request, address, productID, config_name, sensor_name):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    
    configDN = request.POST.get('configDN', None)
    config = None;
    if configDN == None:
        ldap_info = request.session['ldap'][address]
        (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
    else:
        config = configuration.get_config_by_dn(ldap_connection, configDN)

    sensor_config = configuration.get_sensor_config(ldap_connection, config)

    #check that sensor_name is specified
    if not sensor_name or len(sensor_name) == 0:
        sensor_name = None

    #create dynamic form !!!
    form_clazz = sensor.get_sensor_form(sensor_config.data, sensor_name = sensor_name)
    sensor_instance = form_clazz.sensor
    # check request method
    form = None
    refresh_sensor_list = False
    is_sensor_saved = False
    if request.method == 'GET':
        form = form_clazz()
    elif request.method == 'POST':
        form = form_clazz(request.POST)
        if form.is_valid():
            saved_sensor_name, sensor_xml = form.update_xml()
            # save data
            configuration.update_settings(ldap_connection, sensor_config.dn, sensor_xml)
            is_sensor_saved = True
            if not sensor_name:
                sensor_name = saved_sensor_name
                refresh_sensor_list = True

    return render_to_response('ssim/config/sensor.html', {'productID':productID, 
        'config':config,
        'sensor':sensor_instance,
        'form':form,
        'address':address,
        'action':request.path,
        'update_item_list':refresh_sensor_list,
        'sensor_saved':is_sensor_saved},
        mimetype="text/html")
Ejemplo n.º 13
0
def delete_sensor(request, address, productID, config_name, sensor_name):
    ldap_connection = utils.get_ldap_connection(request.session, address)

    configDN = request.POST.get('configDN', None)
    config = None;
    if configDN == None:
        ldap_info = request.session['ldap'][address]
        (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
    else:
        config = configuration.get_config_by_dn(ldap_connection, configDN)

    sensor_config = configuration.get_sensor_config(ldap_connection, config)
    sensor_xml = sensor.remove_sensor_from_xml(sensor_config.data, sensor_name)
    # save data
    configuration.update_settings(ldap_connection, sensor_config.dn, sensor_xml)
    
    return redirect("/ssim/config/%s/product/%s/config/%s/sensors/" %
        (address, productID, config_name))
Ejemplo n.º 14
0
def change_sensor_status(request, address, productID, config_name, sensor_name):
    try:
        ldap_connection = utils.get_ldap_connection(request.session, address)

        configDN = request.POST.get('configDN', None)
        config = None;
        if configDN == None:
            ldap_info = request.session['ldap'][address]
            (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
        else:
            config = configuration.get_config_by_dn(ldap_connection, configDN)

        sensor_config = configuration.get_sensor_config(ldap_connection, config)
        status, sensor_xml = sensor.change_status(sensor_config.data, sensor_name)
        # save data
        configuration.update_settings(ldap_connection, sensor_config.dn, sensor_xml)
    except Exception as ex:
        status = ex
    return HttpResponse(status,
            mimetype='text/plain')
Ejemplo n.º 15
0
def distribute_config(request, address, productID, config_name):
    status = 'success'
    try:
        ldap_connection = utils.get_ldap_connection(request.session, address)

        configDN = request.POST.get('configDN', None)
        config = None;
        if configDN == None:
            ldap_info = request.session['ldap'][address]
            (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
        else:
            config = configuration.get_config_by_dn(ldap_connection, configDN)
        if len(config.elements) > 0:
            utils.distribute_config(address, request.session, config.elements)
        else:
            status = 'There are no Agents related with current configuration'
    except Exception as ex:
        status = ex

    return HttpResponse(status,
            mimetype='text/plain')
Ejemplo n.º 16
0
def config_agents(request, address, productID, config_name):
    ldap_connection = utils.get_ldap_connection(request.session, address)

    configDN = request.POST.get('configDN', None)
    config = None;
    if configDN == None:
        ldap_info = request.session['ldap'][address]
        (product_instance, config_root, config) = configuration.get_config_by_name(ldap_connection, ldap_info['domain'], productID, config_name)
    else:
        config = configuration.get_config_by_dn(ldap_connection, configDN)

    #save data
    params = request.GET
    if request.method == 'POST':
        params = request.POST
        agents.save(ldap_connection, config, request.POST.getlist('agents'))

    #get all agents and agents references
    ldap_info = request.session['ldap'][address]
    all_agents = location.all(ldap_connection, ldap_info['domain'])
    linked_agents = []
    if len(config.elements_names) > 0:
        linked_agents = location.all(ldap_connection, ldap_info['domain'], config.elements_names)

    # filter all_agents
    for item in linked_agents:
        if item in all_agents:
            all_agents.remove(item)
    
    return render_to_response('ssim/config/agents-tab.html', {'productID':productID,
        'config':config,
        'all_agents': all_agents,
        'agents': linked_agents,
        'address': address,
        'action':request.path},
        mimetype="text/html")
Ejemplo n.º 17
0
def config_by_product_id(request, address, productID, message = None):
    ldap_connection = utils.get_ldap_connection(request.session, address)
    ldap_info = request.session['ldap'][address]
    (product_instance, config_root, config_list) = configuration.configurations(ldap_connection, ldap_info['domain'], productID)
    return render_to_response('ssim/configurations.html', {'product':product_instance,'config_root':config_root, 'configurations':config_list, 'address':address},
        mimetype="text/html")
Ejemplo n.º 18
0
def index(request, address = None):
    ldap_connection = None
    try:
        ldap_connection = utils.get_ldap_connection(request.session, address)
    except Exception, err:
        log.info("Cannot connect to LDAP " + address + ". " + str(err))