Instalar OpenLdap con samba en debian wheezy

Instalar OpenLdap con samba en Debian Wheezy

La presente guía es para mostrar la manera correcta de instalar openldap y samba bajo linux para poder tener un servidor de autenticación centralizado y samba para que nos provea un controlador de dominio, en este caso primario. Su aplicación en micro y pequeñas redes (de 10 - 10000 tablas sin problemas) es de mucha utilidad y relativamente cómoda administración.
De más está decir que el coste económico es cero, ya que como administradores de redes, jefes de infraestructura deberíamos tenerlo presente con la finalizad de minimizar los costes del área de TI.
Voy a tratar de ser lo más sencillo posible los pasos y colocaré todos los archivos de configuración para no dejar nada vacío.

Condiciones iniciales:
Dominio    =   mipc.com
ip-address  =   172.16.0.3
netmask     =   255.255.255.0
hostname   =   ldap.mipc.com
Gateway    =   172.16.0.1
Serv. DNS =   ns.mipc.com        =   172.16.0.1
Serv. web  =    www.mipc.com  =   172.16.0.4

Empecemos:

1. Instalación  de ldap y samba.
aptitude install slapd ldap-utils samba-doc libnss-ldap libpam-ldap nscd samba smbclient smbldap-tools ldap-account-manager-lamdaemon

Se contesta todo por default, ya que vamos a modificar los archivos de configuración

ejecutar lo siguiente:
# zcat /usr/share/doc/samba-doc/examples/LDAP/samba.schema.gz > /etc/ldap/schema/samba.schema
# slappaswd    -------------> al ejecutar se ingresa la contraseña del administrador del árbol ldap
# ldap-account-manager-lamdaemon
# adduser ldapadmin
# slaptest -v -u
# rm -rf /var/lib/ldap/*
# service nscd restart
# mkdir -p /var/lib/samba/netlogon /var/lib/samba/profiles
# chown -Rf root:root /var/lib/samba/netlogon /var/lib/samba/profiles
# chmod 1777 /var/lib/samba/profiles
# zcat /usr/share/doc/smbldap-tools/examples/smbldap.conf.gz > /etc/smbldap-tools/smbldap.conf
# cp /usr/share/doc/smbldap-tools/examples/smbldap_bind.conf /etc/smbldap-tools/smbldap_bind.conf
# chmod 640 /etc/smbldap-tools/smbldap.conf /etc/smbldap-tools/smbldap_bind.conf
# chown root:openldap /etc/smbldap-tools/smbldap.conf /etc/smbldap-tools/smbldap_bind.conf
# net getlocalsid
# smbldap-populate
# pdbedit -L
# pdbedit -Lv root

Ahora voy a dejar los archivos de configuración para que lo adapten a sus necesidades.

nano /etc/ldap/ldap.conf
BASE    dc=mipc,dc=com
URI     ldap://ldap.mipc.com
TLS_CACERT      /etc/ssl/certs/ca-certificates.crt

nano /etc/ldap/slapd.conf

include         /etc/ldap/schema/core.schema

include         /etc/ldap/schema/cosine.schema

include         /etc/ldap/schema/nis.schema

include         /etc/ldap/schema/inetorgperson.schema

include         /etc/ldap/schema/samba.schema

pidfile         /var/run/slapd/slapd.pid

argsfile        /var/run/slapd/slapd.args

loglevel        none

modulepath      /usr/lib/ldap

moduleload      back_hdb

sizelimit 500

tool-threads 1

backend         hdb

database        hdb

suffix          "dc=mipc,dc=com"

rootdn          "uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com"

rootpw          {SSHA}flssWgKAVN+9l2nhpd7NkOgpNStVBsK0

directory       "/var/lib/ldap"

dbconfig set_cachesize 0 2097152 0

dbconfig set_lk_max_objects 1500

dbconfig set_lk_max_locks 1500

dbconfig set_lk_max_lockers 1500

index   objectClass                     eq,pres

index   ou,cn,sn,mail,givenname         eq,pres,sub

index   uidNumber,gidNumber,memberUid   eq,pres

index   loginShell                      eq,pres

index   uid                             pres,sub,eq

index   displayName                     pres,sub,eq

index   nisMapName,nisMapEntry          eq,pres,sub

index   sambaSID                        eq

index   sambaPrimaryGroupSID            eq

index   sambaDomainName                 eq

index   default                         sub

index   uniqueMember                    eq

index   sambaGroupType                  eq

index   sambaSIDList                    eq

lastmod         on

checkpoint      512 30

access to attrs=userPassword,sambaNTPassword,sambaLMPassword,sambaPwdMustChange,sambaPwdLastSet

        by self write

        by anonymous auth

        by * none

access to attrs=shadowLastChange,shadowMax

        by self write

        by * read

access to *

        by * read

nano /etc/libnss-ldap.conf

base dc=mipc,dc=com

uri ldap://172.16.0.3/

ldap_version 3

rootbinddn uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com

bind_policy soft

pam_filter objectclass=PosixAccount

pam_login_attribute uid

pam_password crypt

nss_base_passwd ou=Usuarios,dc=mipc,dc=com?one

nss_base_shadow ou=Usuarios,dc=mipc,dc=com?one

nss_base_group          ou=Grupos,dc=mipc,dc=com?one

nano /etc/nsswitch.conf

passwd:         files ldap

group:          files ldap

shadow:         files ldap

hosts:          files dns

networks:       files

protocols:      db files

services:       db files

ethers:         db files

rpc:            db files

netgroup:       nis

nano /etc/pam_ldap.conf

base dc=mipc,dc=com

uri ldap://172.16.0.3/

ldap_version 3

rootbinddn uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com

bind_policy soft

pam_filter objectclass=PosixAccount

pam_login_attribute uid

pam_password crypt

nss_base_passwd ou=Usuarios,dc=mipc,dc=com?one

nss_base_shadow ou=Usuarios,dc=mipc,dc=com?one

nss_base_group          ou=Grupos,dc=mipc,dc=com?one

nano /etc/pam.d/common-account

account [success=2 new_authtok_reqd=done default=ignore]        pam_unix.so 

account [success=1 default=ignore]      pam_ldap.so 

account requisite                       pam_deny.so

account required                        pam_permit.so

nano /etc/pam.d/common-auth

auth    [success=2 default=ignore]      pam_unix.so nullok_secure

auth    [success=1 default=ignore]      pam_ldap.so use_first_pass

auth    requisite                       pam_deny.so

auth    required                        pam_permit.so

nano /etc/pam.d/common-password

password        [success=2 default=ignore]      pam_unix.so obscure crypt

password        [success=1 user_unknown=ignore default=die]     pam_ldap.so use_authtok try_first_pass

password        requisite                       pam_deny.so

password        required                        pam_permit.so

nano /etc/pam-.d/common-session

session [default=1]                     pam_permit.so

session requisite                       pam_deny.so

session required                        pam_permit.so

session required        pam_unix.so 

session required        pam_mkhomedir.so 

session optional                        pam_ldap.so 

nano /etc/pam-.d/common-session-noninteractive

session [default=1]                     pam_permit.so

session requisite                       pam_deny.so

session required                        pam_permit.so

session required        pam_unix.so 

session required        pam_mkhomedir.so 

session optional                        pam_ldap.so 

nano /etc/samba/smb.conf

[global]

dos charset = 850

Unix charset = ISO8859-1

workgroup = mipc.com

realm = mipc.com

server string = %h server

map to guest = Bad User

username map = /etc/samba/smbusers

passdb backend = ldapsam:ldap://127.0.0.1/

ldap admin dn = uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com

ldap delete dn = Yes

ldap user suffix = ou=Usuarios

ldap group suffix = ou=Grupos

ldap machine suffix = ou=Maquinas

ldap idmap suffix = ou=idmap

ldap suffix = dc=mipc,dc=com

ldap ssl = no

add user script = /usr/sbin/smbldap-useradd -m %u

delete user script = /usr/sbin/smbldap-userdel %u

add group script = /usr/sbin/smbldap-groupadd -p %g

delete group script = /usr/sbin/smbldap-groupdel %g

add user to group script = /usr/sbin/smbldap-groupmod -m %u %g

delete user from group script = /usr/sbin/smbldap-groupmod -x %u %g

set primary group script = /usr/sbin/smbldap-usermod -g %g %u

add machine script = /usr/sbin/smbldap-useradd -W %u

socket options = TCP_NODELAY SO_RCVBUF=8192 SO_SNDBUF=8192

interfaces = eth0 lo

hosts allow = 127.0.0.1, 172.16.0.0/24

hosts deny = 0.0.0.0

smb ports = 139 445

bind interfaces only = Yes

name resolve order = wins hosts lmhosts bcast

remote announce = 172.16.0.255

unix password sync = yes

ldap passwd sync = yes

passwd program = /usr/sbin/smbldap-passwd -u %u

passwd chat = "Changing *\nNew password*" %n\n "*Retype new password*" %n\n"

logon script = 'logon.bat %U'

logon path = \\%N\profiles\%U

logon path =

logon drive = U:

domain logons = Yes

os level = 65

preferred master = Yes

domain master = Yes

dns proxy = No

wins support = Yes

panic action = /usr/share/samba/panic-action %d

map acl inherit = Yes

case sensitive = No

hide unreadable = Yes

syslog = 0

log file = /var/log/samba/log.%m

max log size = 1000

time server = Yes

[homes]

comment = Home Directories

valid users = %S

read only = No

create mask = 0611

directory mask = 0711

browseable = No

[printers]

comment = All Printers

path = /var/spool/samba

create mask = 0611

directory mask = 0711

printable = Yes

browseable = No

[print$]

comment = Printer Drivers

path = /var/lib/samba/printers

create mask = 0611

directory mask = 0711

[netlogon]

path = /var/lib/samba/netlogon

browseable = No

create mask = 0611

directory mask = 0711

[profiles]

path = /var/lib/samba/profiles

force user = %U

read only = No

create mask = 0611

directory mask = 0711

guest ok = Yes

profile acls = Yes

browseable = No

csc policy = disable

[public]

path = /tmp

read only = No

guest ok = Yes

create mask = 0611

directory mask = 0711

nano /etc/smbldap-tools/smbldap.conf

SID="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # ----------> colocar lo que sale de ejecutar net getlocalsid

sambaDomain="mipc.com"

slaveLDAP="172.16.0.3"

slavePort="389"

masterLDAP="172.16.0.3"

masterPort="389"

ldapTLS="0"

ldapSSL="0"

verify="require"

cafile="/etc/smbldap-tools/ca.pem"

clientcert="/etc/smbldap-tools/smbldap-tools.example.com.pem"

clientkey="/etc/smbldap-tools/smbldap-tools.example.com.key"

suffix="dc=mipc,dc=com"

usersdn="ou=Usuarios,dc=mipc,dc=com"

computersdn="ou=Maquinas,dc=mipc,dc=com"

groupsdn="ou=Grupos,dc=mipc,dc=com"

idmapdn="ou=Idmap,${suffix}"

sambaUnixIdPooldn="sambaDomainName=${sambaDomain},${suffix}"

scope="sub"

password_hash="CRYPT"

password_crypt_salt_format="%s"

userLoginShell="/bin/bash"

userHome="/home/%U"

userHomeDirectoryMode="700"

userGecos="System User"

defaultUserGid="513"

defaultComputerGid="515"

skeletonDir="/etc/skel"

shadowAccount="1"

defaultMaxPasswordAge="345"

userSmbHome="\\ldap\%U"

userProfile="\\ldap\profiles\%U"

userHomeDrive="U:"

userScript="logon.bat"

mailDomain="mipc.com"

with_smbpasswd="0"

smbpasswd="/usr/bin/smbpasswd"

with_slappasswd="0"

slappasswd="/usr/sbin/slappasswd"

nano /etc/smbldap-tools/smbldap_bind.conf

slaveDN="uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com"

slavePw="yyyyyyy"       # ----------------------------> poner la contraseña de ldapadmin en texto plano

masterDN="uid=ldapadmin,ou=Usuarios,dc=mipc,dc=com"

masterPw="yyyyyyy"     # ----------------------------> poner la contraseña de ldapadmin en texto plano

Con todo esto no hay pierde.

Saludos.

Controlar remotamente Raspberry Pi vía web

En ésta nueva entrada voy a exponer mi manera de para poder controlar los puertos GPIO de la Raspberry Pi de manera remota, utilizando Lighttpd y php como servidor web, navegadores web y smartphone android como clientes.
Actualmente cuento con 1 placa Raspberry Pi rev2.0 y 1 placa Raspberry Pi 2 con la que realizo mis pruebas caseras, lo he realizado en ambos hardwares sin problemas ni cambios relevantes.
El presente repaso lo realizaré en la raspberry Pi 1 rev2.0

Vamos a instalar el servidor lighttpd por ser muy ligero en comparación con apache2. Usaremos php para programar la página web a la que se tendrá acceso vía web y vía aplicativo android. Usaremos scripts en python y bash muy básicos para poder controlar los puertos GPIO de la raspberry.
Desde php llamaremos a los scripts para que interactúe con el usuario.
La práctica consiste en prender, apagar y parpadear un led desde python y/o bash conectado al pin 11 del conector P1. El ánodo será conectado a una resistencia de 4.7k a voltaje para limitar la corriente y el cátodo al pin 11.

Empecemos:

pi@raspberry~$ sudo aptitude install lighttpd php-config php-pear php-xml-parser php5-cgi php5-cli php5-common
No voy a explicar la configuración de php con lighttpd ya que hay abundante información de ello en la web.
Recomiendo la lectura del siguiente blog propiedad de LiGNUxero que a mi parecer está muy bien explicados los pasos básicos para poner en marcha lighttpd y php:
http://blog.desdelinux.net/lighttpd-un-servidor-web-muy-agil-y-liviano/

Ahora vamos a /var/www y dentro crearé la carpeta led. Dentro de la carpeta led crearemos el index.php que contendrá el código en php.
pi@raspberry /var/www/led~$ sudo vim index.php


<html>
<head>
<!--index.php-->
</head>
<body>
<!--GPIO17-->
<form action="" method="post">
Control de Led en el puerto 17
&nbsp;<input type="submit" name="prenderLED" value="Prender">
<input type="submit" name="apagarLED" value="Apagar">
<input type="submit" name="parpadearLED" value="Parpadear">
</body>
</html>
<?php
// Funciones PHP del pin GPIO 17
if ($_POST[prenderLED]) {
exec("sudo python /var/www/led/gpio/prenderLED.py");
}
if ($_POST[apagarLED]) {
exec("sudo python /var/www/led/gpio/apagarLED.py");
}
if ($_POST[parpadearLED]) {
exec("sudo python /var/www/led/gpio/parpadearLED.py");
}
// Fin Funciones PHP del pin GPIO 17
?>
Debería quedar así:

Control de Led en el puerto 17
Raspberry Pi rev2.0
 

Luego dentro de la carpeta led, crearé la carpeta gpio; aquí alojaré los scripts en python y bash que serán llamados por el index.php.
Usaremos el pin gpio 17, ya que es el número 0 en la tabla de comparación con WiringPi.

pi@raspberry /var/www/led/~$ mkdir gpio
pi@raspberry /var/www/led/gpio~$ nano prendeLED.py

#!/usr/bin/env/ python
## enciende.py
#Importamos la libreria y le cambiamos el nombre a GPIO
import RPi.GPIO as GPIO
#Establecemos el sistema de numeracion que queramos, 
#en este caso el sistema BCM
GPIO.setmode(GPIO.BCM)
#Configuramos el pin GPIO 17 como una salida
GPIO.setup(17, GPIO.OUT)
#Encendemos el led
GPIO.output(17, GPIO.HIGH)
GPIO.cleanup(); Liberamos el GPIO 17

pi@raspberry /var/www/led/gpio~$ nano apagaLED.py

#!/usr/bin/env/ python
## apaga.py
#Importamos la libreria y le cambiamos el nombre a GPIO
import RPi.GPIO as GPIO
#Establecemos el sistema de numeracion que queramos, 
#en este caso el sistema BCM
GPIO.setmode(GPIO.BCM)
#Configuramos el pin GPIO 17 como una salida
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
#Apagamos el led
GPIO.output(17, GPIO.LOW)
#Y liberamos el GPIO 17
GPIO.cleanup()

pi@raspberry /var/www/led/gpio~$ nano parpadearLED.py

#!/usr/bin/env/ python
import RPi.GPIO as GPIO
import time
#Establecemos el sistema de numeracion que queramos, 
#en este caso el sistema BCM
GPIO.setmode(GPIO.BCM)
#Configuramos el pin GPIO 17 como una salida
GPIO.setup(17, GPIO.OUT)
#Encendemos y apagamos el led 5 veces
for i in range(0,5):
 GPIO.output(17, GPIO.HIGH)
 time.sleep(1)
 GPIO.output(17, GPIO.LOW)
 time.sleep(1)
#Y liberamos el GPIO 17
GPIO.cleanup()

Ahora creamos los scripts en bash si es que no queremos hacerlo en python.

pi@raspberry /var/www/led/gpio~$ nano prenderLED.sh

#!/bin/bash
echo 17 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio17/direction
echo 0 > /sys/class/gpio/gpio17/value
#Liberamos el PIN asociado
echo 17 > /sys/class/gpio/unexport

pi@raspberry /var/www/led/gpio~$ nano apagarLED.sh

#!/bin/bash
echo 17 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio17/direction
echo 1 > /sys/class/gpio/gpio17/value
echo 17 > /sys/class/gpio/unexport

pi@raspberry /var/www/led/gpio~$ nano parpadearLED.sh

#!/bin/bash
echo 17 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio17/direction
for i in $(seq 1 5)
 do
   echo 1 > /sys/class/gpio/gpio17/value
   sleep 1
   echo 0 > /sys/class/gpio/gpio17/value
   sleep 1
 done
echo 17 > /sys/class/gpio/unexport

Ahora estoy trabajando en crear un apk que pueda controlarlo vía android. Existe una página llamada AppInventor para poder crear nuestro código online y así no tener que instalar el pesado Android Studio.
Cuando culmine, incluiré el código.
Por lo pronto hasta aquí.
Saludos;
JPC

Programando en Octave y C - Diagrama de Moody

Estimados, Después de publicar temas relacionados a electrónica, informática, redes, etc; hoy presento el desarrollo de un tema totalmente diferente. La aplicación de la programación en C y Octave para solucionar problemas de Ingeniería Hidráulica. Esto a raíz de que mi padre está cursando su Maestría en Ingeniería Hidráulica en la UNI - Perú y necesitaba una herramienta que le permita calcular lo que a continuación expongo. En el curso de flujos en superficies libres tocaron el tema del uso del Diagrama de Moody para calcular el factor de fricción de un determinado fluido bajo ciertas condiciones. Esto podía tener dos escenarios dependiendo de los valores obtenidos preliminarmente. Podía ser un escenario de flujo laminar o flujo turbulento y ésto depende del rango en que se encuentre el número de Reynolds. Si éste número se encuentra entre 0 y 2300 e considera que el fluido se encuentra en régimen laminar y la fórmula para obtener el factor de fricción es : f = 64/nReynolds. Si está por encima de los 2300, se considera que el fluido se encuentra en régimen turbulento y se utiliza la fórmula de Colebrook para obtener el factor de fricción, además de tener en cuenta otra variable conocida como Rugosidad relativa (ed):

La cual es necesario iterar hasta encontrar el factor.
Alternativamente se puede usar la expresión propuesta por Haaland, en el que logra despejar "f" de la ecuación de Colebrook.

He usado Octave (altamente compatible con matlab) para generar el diagrama de Moody.
Lo interesante con esto, es que aparte de ayudar a mi padre, he aprendido comandos interesantes como num2str, loglog, text y he reforzado mi conocimiento de bucles anidados y uso de arrays en Octave/Matlab.
Expongo el código por si alguien esté interesado.
Con ese código se puede obtener el diagrama de Moody para régimen turbulento, el cual se puede usar para hallar aproximadamente el factor de fricción para un determinado número de Reynolds y rugosidad relativa.

%%PROGRAMA QUE GRAFICA EL DIAGRAMA DE MOODY - FLUJO TURBULENTO
%%SE ITERA CON DETERMINADOS VALORES DE RUGOSIDAD RELATIVA E/D vs nReynolds
%%EL NUMERO DE REYNOLDS SE CALCULA EN BASE A LA FORMULA:
%%     nReynolds = VELOCIDAD*DENSIDAD*DIAMETRO_TUBERIA/MU
%% LA RUGOSIDAD RELATIVA SE CALCULA EN BASE A LA FORMULA:
%%     e/DIAMETRO = ed
%% EL COEFICIENTE DE RUGOSIDAD (f) SE CALCULA EN BASE A LA FORMULA DE HAALAND:
%% 1/f^(1/2)=-1.8*log[(6.9/nReynolds)+(ed/3.7)^1.11]
clear all;close all;clc;
nReynolds = [3000];
ed = [0.00001 0.00002 0.00005 0.0001 0.0002 0.0004 0.0006 0.0008 0.001 ...
0.0015 0.002 0.003 0.004 0.006 0.008 0.01 0.0125 0.015 0.0175 0.02 0.025 ...
0.03 0.035 0.04 0.045 0.05 0.06 0.07];
f = [];
for i = 2:214
  nReynolds = [nReynolds 1.05015*nReynolds(i-1)];
end
hold on;
for i = 1:length(ed)
  for j = 1:length(nReynolds)
  f = 0.30864/(log10((6.9/nReynolds(j))+(ed(i)/3.7)^1.11))^2;
  eval(num2str(i,'f%d(j)=f;'));
  end
end
figure (1)
hold on;grid on;
for i=1:length(ed)
eval(num2str(i,'loglog(nReynolds,f%d)'))
end
title({'Diagrama de Moody - Seccion Flujo Turbulento'; ' '; ...
'{f} ^{-1/2} = -1.8 * log10 [ ( 6.9 / nReynolds ) + ( ed / 3.7 ) ^{1.11}]'})
xlabel ('Number Reynolds'); ylabel ('Factor friction'); 
for i=1:length(ed)
VAL = ed(i);
str = ['ed = ',num2str(VAL)];
text(nReynolds(214),eval(num2str(i,'f%d(214)')),str);
end

Con este algoritmo, se obtiene la siguiente gráfica:

Si necesitamos un programa que calcule analíticamente el factor de fricción para ambos regímenes, presento este programa hecho en C y compilado con gcc bajo Debian 8.2.

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define DENSIDAD 1.23
#define MHU 0.0000179

void muestraEncabezado ()
{
puts("UNIVERSIDAD NACIONAL DE INGENIERIA\t\t MAESTRIA EN INGENIERIA HIDRAULICA\n");
    puts("\n\t\t\t PROGRAMA QUE DETERMINA EL TIPO \n\t\t  DE REGIMEN DEL AIRE A TRAVES DE UNA TUBERIA \
    \n\t\t\tY CALCULA EL FACTOR DE FRICCIÓN\n");
    puts("Alumno    : Jorge Piscoya Fernández");
    puts("Curso     : Flujo en Superficie Libre");
    puts("-------------------------------------\n");
}
float mostrarReynolds(float diametro, float velocidad)
{
    return (diametro*velocidad*DENSIDAD)/(MHU);
}
float regimenLaminar (float diametro, float velocidad)
{
    return 64 / mostrarReynolds(diametro, velocidad);
}
float regimenTurbulento (float ed, float diametro, float velocidad)
{
    float f;
    float nR;
    nR = mostrarReynolds(diametro, velocidad);
    f = 0.30864/(pow(log10((6.9/nR)+(pow(ed/3.7,1.11))),2));
    return f;
}
int main()
{
    float diametro = 0;
    float velocidad = 0;
    float nReynolds = 0;
    muestraEncabezado();
    printf("Ingrese diámetro de tubería en (m): ");
    scanf("%f", &diametro);
    printf("\n");
    printf("Ingrese la velocidad del fluido (m/s): ");
    scanf("%f", &velocidad);
    printf("\n");
    nReynolds = mostrarReynolds(diametro, velocidad);
    printf("El número de Reynolds para el fluido ingresado es: %f\n", nReynolds);
    if (nReynolds < 2300)
    {
        puts("El fluido se encuentra en régimen laminar");
        printf("El coeficiente de rugosidad es: %f\n", regimenLaminar(diametro, velocidad));
    }
    else
    {
        float ed, f;
        puts("El fluido se encuentra en régimen turbulento\n\n");
        puts("Se procederá a calcular el factor de fricción en Reg. Turbulento\n");
        printf("Ingrese el valor de la Rugosidad Relativa (ed) del medio: ");
        scanf("%f", &ed);
        f = regimenTurbulento(ed, diametro, velocidad);
        printf("\nEl factor de fricción en regimen turbulento es: %f\n",f);
    }
    puts("\nPresione ENTER para salir\n");
    while(getchar() != '\n');
    getchar();
    return 0;
}

Y se obtiene la siguiente ventana:

Voy a intentar meter ncurses para que sea más colorida la interface, pero será en otro momento.
Para ejecutarlo en Windows, pueden usar DEV-C++ ya que es parte del standar ANSI C, así podrán obtener el ejecutable para windows.

Para poder realizar este trabajo, he seguido este manual teórico más la explicación de mi padre:
http://es.scribd.com/doc/67350243/Diagrama-de-Moody

Con esto reforzado mi conocimiento básico de manejo de funciones definidas para el desarrollo del algoritmo. Si tienen alguna sugerencia de cómo mejorar el código, es bienvenido. Saludos

Grabar PIC's de Microchip en linux

La presente entrada pretende resumir de una vez por todas la manera más sencilla de poder "quemar" nuestros microcontroladores pic de microchip desde GNU/Linux. La experiencia la inicié desde que tenía instalado debian 6 (Squeeze), osea hace 4 años, pasando por debian 7 (mi tan querida debian wheezy) y ahora en debian 8.
Uno de los software más usados para programar los pics de microchip en Wind2 es de lejos Pickit en sus versiones 2 y 3 que usa el puerto USB. Microchip ha publicado el esquemático de la placa programadora así que existen muchos clones personalizados en la web. Este hardware usa un microcontrolador 12f2550 que tiene un bootloader específico para interactuar con la pc, así que si necesitamos crear nuestra propia placa a partir de los planos, es necesario quemar el bootloader desde otro programador.
Para linux, Microchip ha puesto a nuestra disposición la herramienta pk2cmd, que no tiene interfaz gráfica y sólo se maneja por comandos desde la terminal, por lo que para los que recién se inician en linux y microchip puede resultar un poco complicado entender.

La placa que actualmente uso es prestada de un compañero del trabajo
(Gracias VISU) y es la que usaré para poder exponer este artículo.

El pic será "quemado" a través del método ICSP. Probaremos con los pic's 16F877A y 12F675 (cuya ventaja es que posee un oscilador interno, ideal para proyectos compactos).
Voy a dejar el código fuente en mi dropbox y compartiré el link para que lo puedan descargar y así evitarse tanto dolor de cabeza leyendo muchos artículos que lo que me generaron fue confusión, ya que unos hablaban de una versión, otros de otra versión, otros ponían una sintaxis y a vaces funcionaba, a veces no, etc.
Ahora paso a detallar la instalación.
Antes de instalar, debemos tener instalado las librerías que manejan el puerto usb.
$ sudo aptitude install libusb++-dev

1. Bajar código fuente.
Bajamos el código fuente de aquí. Descomprimir con el siguiente comando:
$ tar -xjf pk2cmd_v1.21.tar.bz2

Luego ingresar a la carpeta descomprimida:
$ cd pk2cmd

Compilar el código fuente:
$ make linux

Al culminar la compilación, generará el ejecutable pk2cmd. Éste debemos copiarlo dentro del /usr/local/bin.
$ sudo cp pk2cmd /usr/local/bin

Luego darle permisos de ejecución.
$ sudo chmod 755 /usr/local/bin/pk2cmd

Luego hay instalar la base de datos de los microcontroladores soportados por esta versión. Existen varias versiones de este archivo. Yo usé el que se puede encontrar en la página de archlinux.
Bajamos la base desde aquí. Descomprimimos.

$ unzip PK2DeviceFile_1.63.148.zip

Creamos la siguiente carpeta donde se copiará ese archivo y luego lo copiamos:
$ sudo cp /usr/share/pk2 && sudo cp PK2DeviceFile.dat /usr/share/pk2/

Damos permisos de lectura y escritura.
$ sudo chmod 777 /usr/share/pk2/PK2DeviceFile.dat

Luego creamos el grupo microchip y nos agregamos a ese grupo.
$ sudo groupadd microchip
$ sudo gpasswd -a $USER microchip

Luego creamos este archivo para poder interactuar con el quemador:
$ sudo nano /etc/udev/rules.d/026_microchip.rules

Ydentro del archivo creado copiamos lo siguiente:
#PICKit 2
ATTR{idVendor}=="04d8", ATTR{idProduct}=="0033", OWNER:="root", GROUP:="microchip",MODE:="0660"

Dentro de nuestro /home/$USER/.bashrc, agregamos la siguiente línea:
export PATH=$PATH:/usr/share/pk2

Reiniciamos y cuando conectamos el "quemador" pickit2 a nuestro linux, verificamos que lo haya reconocido:
$lsusb.
Bus 002 Device 004: ID 0bda:58de Realtek Semiconductor Corp.
Bus 002 Device 025: ID 046d:c534 Logitech, Inc.
Bus 002 Device 022: ID 04d8:0033 Microchip Technology, Inc. PICkit2
Bus 002 Device 014: ID 152d:2329 JMicron Technology Corp. / JMicron USA Technology Corp. JM20329 SATA Bridge
Bus 002 Device 005: ID 058f:9254 Alcor Micro Corp. Hub
Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 067b:2303 Prolific Technology, Inc. PL2303 Serial Port
Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

$pk2cmd -?v

Executable Version     :   1.21.00
Device File Version     :   1.63.148
OS Firmware Version :   2.32.00


Operation Succeeded

2. Quemando el pic.
Con eso ya podemos grabar nuestros .hex en el microcontrolador.
Por ahora sólo me dedicaré al proceso de quemar, la programación y la compilación la presentaré en una nueva entrada.

El pic que usaremos en esta ocasión es 16f877A y lo que hace nuestro programa es parpadear un led en el puerto RB0 (pin 33)

Primero borramos el pic.
$pk2cmd -PPIC16F877A -E

Para grabar usaremos la siguiente sintaxis:
$pk2cmd -PPIC16F877A -M -F/ruta_donde_está_el_hex.hex

En mi caso, yo tengo el .hex en mi home:

kiko@debian8:~$ pk2cmd -PPIC16F877A -M -F/home/kiko/bled.hex
PICkit 2 Program Report
2-6-2015, 0:40:06
Device Type: PIC16F877A

Program Succeeded.

Operation Succeeded

Lamentablemente no poseo un cristal, por lo que no puedo poner una foto del pic funcionando :-(. Pero voy a darme un tiempo para comprarlo y actualizar el post.

Ahora programaremos el pic 12F675

Ejecutamos los mismos comandos:
Borramos el pic:
$pk2cmd -PPIC16F675 -E

Pasamos el hex al pic. Este hex linkea un led conectado al pin 2.
$pk2cmd -PPIC12F675 -M -F/home/kiko/blink_12f675.hex
PICkit 2 Program Report
2-6-2015, 1:06:18
Device Type: PIC12F675

Program Succeeded.

Operation Succeeded

Como en este caso, el pic tiene un oscilador interno, en la programación he aprovechado para configurarlo y así poder tener un video con "quemada" realizada y el pic funcionando.

El video lo pueden ver aquí.


Ahora resumo los comandos que se van a necesitar al momento de trabajar con pk2cmd.

$ pk2cmd -P{PICxxx} -E   --------------- este comando borra el pic PICxxx definido

$ pk2cmd -P{PICxxx} -M -F/ruta.hex ----- graba el .hex en el pic PICxxx

$ pk2cmd -P{PICxxx} -Y -F/ruta.hex ------ compara el firmware cargado con el original para verificar si grabó correctamente.

$ pk2cmd -P{PICxxx} -GF/tmp.hex ---- lee el hexadecimal grabado en el pic y lo guarda en tmp.hex

$ pk2cmd -?v -------- verifica la versión de pk2cmd instalada.

Puerto serial con python y Arduino Mega2560

Siguiendo con las entradas al blog y aprovechando que ésta semana he tenido un poco de tiempo y teniendo a la madrugada como espacio de inspiración, publico un tema que tenía en el tintero desde ya hace tiempo. Manejo de puerto serial de la pc y comunicación a través de éste con el mundo exterior.
Si bien es cierto que el puerto serial está rezagado por el puerto USB, es necesario indicar que la comunicación serial es aún muy usada, ya que la comunicación bluetooth la usa, los xbee también, así como muchos otros equipos aún usan la comunicación serial bajo el protocolo RS232.
En este caso, el ejercicio que he realizado es el siguiente: Realizar una programación en python (lenguaje que últimamente he venido trabajando y en el cual he encontrado mucho potencial en la aplicación a mi maestría) que escriba datos en el puerto serial de tal manera que sean reconocidos por la interfaz externa y ejecute eventos en base a lo que reciben.
La interfaz externa usada es Arduino, que contiene 4 puertos seriales y cuya programación está diseñada para usar uno de ellos para recibir los datos que son enviados por python y ejecutar los eventos configurados.
El programa escrito en python envía a través del puerto serial 4 caracteres: R, G, Y, C que hacen referencia a los colores Red, Green, Yellow y el caracter C que hace referencia a la palabra Clear. Los caracteres RGY son generados y enviados de forma aleatoria. Esto lo realiza en un bucle que realiza 100 iteraciones ha razón 20 combinaciones por segundos y después de ello envía el caracter C para apagar los leds.
El programa escrito en Arduino configura el puerto Serial1 en modo escucha; al momento de recibir los caracteres enviados por la pc. Si recibe el caracter R, prende el led rojo, si recibe G, prende el verde y si recibe Y, prende el led amarillo. Cada color reconocido apaga los otros dos restantes.

Ahora, vamos a ver los programas escritos. Ambas configuraciones usan 9600 baudios de velocidad.

1. Programa en python
#!/usr/bin/python
#User: linux-pipux
#Ver : 0.1
#S.O.: debian 8
#Python 2.7
import serial
import time
import random

### parametros para el puerto serial ####
port = "/dev/ttyUSB0"
baurate = "9600"

### configuracion del puerto serial #####
s=serial.Serial(port, baurate, timeout=1)

#bucle
for i in range(100):
    a = random.choice(["G", "Y", "R"])
    s.write(str(a).encode() + '\r\n')
    time.sleep(0.05) # tiempo de transicion ON-OFF


#terminado el bucle, se escribe C para apagar los LED's
s.write(str('C').encode() + '\n')

exit();

2. Programa en arduino mega2560

#include <SoftwareSerial.h>
int red=7;
int yellow=6;
int green=5;
int entrada;
void setup() {
Serial1.begin(9600);
pinMode(red,OUTPUT);
pinMode(green,OUTPUT);
pinMode(yellow,OUTPUT);
}
void loop() {
if(Serial1.available()>0){
int entrada=Serial1.read();
if(entrada=='G'){
  digitalWrite(green, HIGH);
  digitalWrite(yellow, LOW);
  digitalWrite(red, LOW);
  Serial1.write(entrada);
}
if(entrada=='Y'){
  digitalWrite(green, LOW);
  digitalWrite(yellow, HIGH);
  digitalWrite(red, LOW);
  Serial1.write(entrada);
}
if(entrada=='R'){
  digitalWrite(green, LOW);
  digitalWrite(yellow, LOW);
  digitalWrite(red, HIGH);
  Serial1.write(entrada);
}
if(entrada=='C'){
  digitalWrite(green, LOW);
  digitalWrite(yellow, LOW);
  digitalWrite(red, LOW);
  Serial1.write(entrada);
}
}
}

En la placa arduino, los LED's están conectados a los puertos 5, 6, 7 con los colores verde, amarillo, rojo respectivamente.
Como mi placa no tiene puerto serie, estoy usando un convertidor USB-TTL que tiene salidas de 5V que alimenta a la placa arduino una vez programado.

imagen

Imagen de la programación en python y arduino.

En el siguiente enlace pongo un video donde se verifica su funcionamiento.
Video

En una próxima entrega, publicaré un post donde python lea temperatura de un sensor DS18B20 y que en función a la temperatura, se prenda un led en el arduino. Por ejemplo si la temperatura está por encima de los 25°C que se prenda el led rojo, si está entre los 23-25°C que se prenda el led amarillo y si está por debajo de los 23°C que se prenda el led verde. Esta vez lo haré con arduino, RaspberryPi y python.

Librerías científicas en lenguaje C - Debian

Después de mucho tiempo de no publicar por varias razones; trabajo, familia, maestría, ocio; vuelvo a publicar un tema que para mí es interesante y ahora más debido a que la maestría que estoy cursando actualmente (Maestría en Telecomunicaciones - UNI) exige cálculos matemáticos avanzados. Es bien sabido que estos cálculos son resueltos por el software MatLab, pero cada año se va haciendo más pesado y es por la gran cantidad de módulos y software especializado que viene de serie. Pero siguiendo la filosofía UNIX "Un programa que haga una cosa, pero que la haga bien", no creo necesario "piratear" (ya que no tengo el dinero para pagar la costosa licencia) para realizar cálculos específicos. Ojo no estoy diciendo que MatLab sea malo, sino que no veo la necesidad de instalar 15 GB de cosas que no voy a utilizar. Además que mi modesta portátil sufre un poco para levantar el programa.
Para matlab existe la alternativa bandera en el mundo del software libre: GNU/Octave. Este poderoso software, además de ser opensource, es potencialmente compatible con muchos comandos que se usan en matlab y posee una sintaxis 100% compatible. De este programa hablaré más adelante ya que merece una publicación diferenciada.

Ahora hablaré de una librería cuya existencia descubrí por casualidad realizando la siguiente consulta en la terminal:

kiko@debian8:~$ apt-cache search scientific | grep lib | sort
Me arrojó entre muchas librerías, unas que me llamaron la atención por su descripción:
libgsl0-dev - GNU Scientific Library (GSL) -- development package
liblapack-dev - Library of linear algebra routines 3
libblas3 - Basic Linear Algebra Reference implementations
libatlas3-base - Automatically Tuned Linear Algebra Software

Especial atención me llamó la librería GSL. Investigando un poco y leyendo su documentación oficial que se encuentra en http://www.gnu.org/software/gsl/manual/ veo que es una poderosa librería que justamente usa las librerías lapack, blas, atlas para realizar cálculos numéricos, cálculo de complejos y cálculo matricial; todo desde programación en C (que es mi preferido pero no soy ningún gurú, apenas aficionado novato).
Para instalar la librería, ejecutamos: sudo aptitude install libgsl0-dev

Veamos un ejemplo simple dada una función de segundo grado con una variable, le asignamos un valor a su variable para obtener el resultado.
La ecuación es la siguiente:
                                       

y = 3x2 + 6x + 7                x=3

                                           
/*
el archivo tiene por nombre ecuacion.c y darle permisos de ejecución: 
chmod 700 ecuacion.c
para compilar usar: gcc -Wall -o ecuacion.o ecuacion.c -lgsl -lgslcblas
para ejecutar: ./ecuacion.o
debe arrojar este resultado: y=52
*/

#include <stdio.h>
#include <gsl/gsl_poly.h>
float x, resultado; 
int main (int argc, char *argv[])
{
        double coeficientes[] = { 7, 6, 3 };
        printf("Ingrese el valor en el que se desea evaluar la función -----> x = ");
        scanf("%f", &x);
        printf("El valor ingresado es: x = %f\n", x);

        resultado = gsl_poly_eval (coeficientes, 3, x);
        printf ("La función a evaluar es -----> y = 3*x2 + 6*x + 7\n");
        printf ("El resultado : y = 3*x2 + 6*x + 7 = %f\n", resultado);
  return 0;
}

Si notamos en la variable "coeficientes", se debe definir los coeficientes de la ecuación empezando por el término independiente continuando hacia el coeficiente de mayor grado.

Ponemos otro ejemplo simple (aunque la programación no tanto ya que me llevó horas leyendo su manual y aún me falta muchas horas más) para que se entienda más a lo que me refiero.
Vamos a calcular las variables de un sistema de ecuaciones lineales de primer grado de 4 variables usando la librería gsl.
Usaremos el ejercicio 1 de la siguiente página: http://profe-alexz.blogspot.com/2012/08/metodo-gauss-sistema-ecuaciones-4x4.html

[ 1 -1 0  0 ] [x] = [-6]

[ 0  1 1  0 ] [y] = [ 3]

[ 0  0 1  2 ] [z] = [ 4]

[ 2  0 0 -3 ] [t] = [ 5]

/*
el archivo tiene por nombre abcd.c y darle permisos de ejecución: chmod 700 xyzt.c
para compilar usar: gcc -Wall -o abcd.o abcd.c -lgsl -lgslcblas
para ejecutar: ./xyzt.o
debe arrojar este resultado: a=31; b=37; c=-34; d=19
*/

#include <stdio.h>
#include <gsl/gsl_linalg.h>
 
int main (int argc, char *argv[])
{

double a_data[] = { 1, -1, 0,  0,
                                0,  1, 1,  0,
                                0,  0, 1,  2,
                                2,  0, 0, -3 };
double b_data[] = { -6, 3, 4, 5 };

gsl_matrix_view m = gsl_matrix_view_array (a_data, 4, 4);
gsl_vector_view b = gsl_vector_view_array (b_data, 4);
gsl_vector *x = gsl_vector_alloc (4);
int s;
gsl_permutation * p = gsl_permutation_alloc (4);
gsl_linalg_LU_decomp (&m.matrix, p, &s);
gsl_linalg_LU_solve (&m.matrix, p, &b.vector, x);
printf ("El valor de cada variable es = \n");
gsl_vector_fprintf (stdout, x, "%g");
gsl_permutation_free (p);
gsl_vector_free (x);
return 0;
}

Al momento de compilar se debe llamar a las librerías gsl y gsclbas que es donde se encuentran definidas todas las entradas que permiten ejecutar las operaciones.
Como se puede apreciar, no hay necesidad de instalar 15GB de matlab, sólo 3MB que es lo que ocupa la librería gsl y sus dependencias.
Lo que sí tenemos que invertir es tiempo en leer su extenso manual donde se define y explica cada comando.

Bueno, espero les haya animado este nano-resumen sobre las librerías de computación científica a investigar.

En la maestría uso python y sus diversos módulos: numpy, scipy, matplotlib, sympy, etc para realizar cálculos avanzados como por ejemplo la más aplicada en mi carrera, La transformada de fourier y todo lo relacionado a ello, pero también al igual que GNU/Octave, tendrá una entrada especial en un posterior post.

Por lo pronto sigo practicando con esta potente librería GSL y acabo de descubrir que hay otra librería especial para trabajar con FFT en C (la verdad que ahora entiendo porque la comunidad científica usa software GNU).
Iré poniendo mis resultados conforme vaya avanzando.
Los invito a instalar las librerías y ejecutar el código para que se vayan familiarizando.

Nos vemos.

--
JPC

Primeros Pasos con Samba File Server; Configuración básica smb.conf

Siguiendo con este uHowTo, ahora pasamos a instalar samba en nuestro server.
Samba es servicio que permite interactuar con redes UNIX - Windows. Se pueden configurar con diversas formas de autenticación, ya sea por user/passwd; domain, server, o share.
Cada uno tiene su ventajas, de los cuales el menos aconsejable es el método share que como lo dice el mismo manual de Red Hat "Los desarrolladores de Samba no recomiendan el uso de la seguridad a este nivel."

 
Empecemos:

root@pruebas:~#aptitude install samba

Instalará las dependencias correspondientes y al final creará entre otras cosas el archivo de configuración de samba en /etc/samba/smb.conf

Luego agregamos los usuarios creados en el tutorial anterior a la base de datos de samba.
root@pruebas:~# smbpasswd -a user1
root@pruebas:~# smbpasswd -a user2
root@pruebas:~# smbpasswd -a user3
En cada uno nos va a pedir que ingresemos su contraseña respectiva que no necesariamente es la misma con la que se hace login en el sistema y es la que usaremos al momento de autenticarnos en los clientes en este caso en los clientes windows.
 
Creamos una copia de seguridad;
root@pruebas:~# cp -p /etc/samba/smb.conf /etc/samba/smb.conf.backup

Ahora para mayor comodidad vamos a eliminar las líneas comentadas. Ésto lo podemos hacer a mano pero la flexibilidad de la terminal y los scripts nos pueden hacer la tarea más facil. Para ello usaremos el comando sed como bien lo tiene documentado nuestros amigos de gentoo en español ( gracias www.gentoo.org por los manuales que son espectaculares). 
root@pruebas:/etc/samba# sed '/#/d' smb.conf.original > smb1.conf && rm smb.conf
root@pruebas:/etc/samba# sed '/^$/d' smb1.conf > smb.conf && rm smb1.conf
Con el primer comando elimino todas las líneas que empiezan con # y lo guardo en un archivo temporal smb1.conf y elimino el archivo smb.conf y con el segundo comando lo que hago es eliminar las líneas en blanco del archivo temporal smb1.conf y guardardo en smb.conf y elimino el archivo temporal smb1.conf.

Listo ahora nos queda un bonito smb.conf para empezar a personalizarlo deacuerdo a nuestras necesidades.

root@pruebas:/etc/samba# cat smb.conf
[global]
   workgroup = mipc
   server string = %h server
   dns proxy = no
   interfaces = 127.0.0.0/8 eth0 172.16.1.0/24
   log file = /var/log/samba/log.%m
   max log size = 1000
   syslog = 0
   panic action = /usr/share/samba/panic-action %d
   encrypt passwords = true
   passdb backend = tdbsam
   obey pam restrictions = yes
   unix password sync = yes
   passwd program = /usr/bin/passwd %u
   passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .
   pam password change = yes
   security = user
[homes]
   comment = Home Directories
   browseable = no
   read only = no
   create mask = 0755
   directory mask = 0755
   valid users = %S
[printers]
   comment = All Printers
   browseable = no
   path = /var/spool/samba
   printable = yes
   guest ok = no
   read only = yes
   create mask = 0700
[print$]
   comment = Printer Drivers
   path = /var/lib/samba/printers
   browsable = yes
   read only = yes
   guest ok = no 
Ahora empezaremos por modificar la línea:
         "workgroup = mipc"

En mi caso le puse = mipc; Ojo esto es el nombre de Grupo, no confundir samba es un servidor NetBios y el formato es solo el nombre, no se puede colocar por ejemplo mipc.com
Luego modificamos la línea:
 interfaces = 127.0.0.0/8 eth0 172.16.1.0/24
y ahí asignamos a samba en que interfaz debe escuchar y en que segmento de red. Yo por facilidad le he puesto que escuche en toda la red 172.16.1.0/24

Luego agregamos el parámetro:
security = user
Esto indica que para acceder a los recursos compartidos se tendrán que autenticar con un usuario/passwd válido en samba. Ojo no es lo mismo usuario de sistema que usuario de recursos compartidos en samba.

El resto de líneas las podemos dejar como está.   

Ahora, pasamos a configurar lo que deseamos compartir:
Yo voy a compartir la carpeta sistemas de propietario sistemas y grupo sistemas y una carpeta shared de propietario nobody y grupo nogroup.

[shared]
    comment = Compartido de users
    path = /home/compartido
    browsable = yes
    writable = yes
    force directory mode = 0777
    guest ok = yes
[sistemas]
    comment = Compartido de users
    path = /home/sistemas
    browseable = no
    writeable = yes
    force directory mode = 0750
    force create mode = 0750
    directory mask = 0750
    create mask = 0750
    force group = sistemas
    valid users = @sistemas
    read list = user3

Con esto he creado un recurso compartido llamado shared que tiene permisos 777 para todo lo que sea creado y que fuerce en cualquier caso contrario, además que se salte la autenticación por usuario con la línea guest ok = yes
Cosa que cualquiera pudiera modificar, leer, ejecutar todo lo que se encuentre aquí. Esto es un recurso útil cuando se quiere un directorio donde todos los usuarios de la red puedan compartir de manera fácil y sin restricciones.
Por el contrario, he creado un recurso sistemas donde sólo los usuarios que son parte del grupo sistemas pueden ingresar y eso lo hago con la línea valid users = @sistemas. Aquí he forzado a que cada carpeta creada por cada usuario tenga los permisos 750, osea que sólo el propietario tiene acceso total a lo que él crea y solo lectura y ejecución a los usuarios que forman parte del grupo sistemas. Esto con la finalizad de garantizar la autoria y autonomía de archivos al usuario creador.

Aqui podemos ver el poder de la jerarquía de permisos en UNIX-LINUX; y es que la línea read list = user3 la he colocado a propósito para verificar que a pesar de haberla colocado y que autoriza al user3 a por lo menos leer los archivos y directorios creados por los usuarios del grupo sistemas, el sistema samba no lo deja ni siquiera entrar, ya que el permiso para "otros" está deshabilitado con la máscara 770.

Con esto podemos seguir creando los recursos que quisieramos, por ejemplo para las diferentes áreas de la empresa que administramos, podemos separar por áreas como contabilidad, finanzas, gerencias, RRHH y que ellos no sepan que existen más recursos compartidos más que la que ha sido asignado.

Más adelante veremos como podemos obtener seguridad a través de usuarios autenticados contra LDAP y así poder configurar un controlador de dominio primario. Todo ésto es posible con el samba actual, que en debian squeeze es 3.5.6.

También veremos como la jerarquía de permisos tradicionales tienen algunas deficiencias frente a las ACL complejas que tienen los sistemas actuales de windows y su sistema de archivos NTFS. Pero en linux también tenemos ACL para manejar escenarios en que los permisos tradicionales simplemente no funcionan. Eso lo veremos en una próxima entrada.