I use Crystal intensively for my work, and I love the language. Simple, concise, it’s almost no bullshit whatsoever. But, I do have a very specific use of it: I make calls to a C library I’ve written. It is clearly not something a lot of people are doing, at least not directly, the crystal standard library is quite extensive.
I trust the Crystal compiler enough to get the memory stuff done, but I may have done a terrible job in the C library and I want to check.
Also, I think that valgrind
is a useful tool to prevent memory errors, like corruption or leaks, and should be used intensively.
Unfortunately, I cannot just use valgrind
to check for memory leaks inside my C library. When I do that, there are way too many errors.
Just a single example:
==21822== 25 errors in context 12 of 15:
==21822== Conditional jump or move depends on uninitialised value(s)
==21822== at 0x3CA89B: GC_push_all_eager (in ./my-application)
==21822== by 0x3DA006: GC_with_callee_saves_pushed (in ./my-application)
==21822== by 0x3CBBC6: GC_push_roots (in ./my-application)
==21822== by 0x3C8936: GC_mark_some (in ./my-application)
==21822== by 0x3C1C4C: GC_stopped_mark (in ./my-application)
==21822== by 0x3C1AF6: GC_try_to_collect_inner (in ./my-application)
==21822== by 0x3CCAFE: GC_init (in ./my-application)
==21822== by 0x1D47A2: *GC::init:Nil (boehm.cr:127)
==21822== by 0x3C12C3: *Crystal::main<Int32, Pointer(Pointer(UInt8))>:Int32 (main.cr:35)
==21822== by 0x196735: main (main.cr:114)
valgrind
produces thousands of warnings like this one with Crystal code, all of them are related to the garbage collector used by the Crystal programming language.
A lot of warnings aren’t related to my code, valgrind
has to ignore most of the warnings.
In order:
--gen-suppressions=all
Each time valgrind
encounters an error, it can produce a code snippet. Here is a minimal example:
# We start valgrind with '--gen-suppressions=all' to produce suppression code.
$ valgrind --gen-suppressions=all --leak-check=full -v ./my-application
[a lot of warnings, errors and other stuff like earlier]
==4364==
==4364== 130 errors in context 13 of 15:
==4364== Conditional jump or move depends on uninitialised value(s)
==4364== at 0x3CA896: GC_push_all_eager (in ./my-application)
==4364== by 0x3DA006: GC_with_callee_saves_pushed (in ./my-application)
==4364== by 0x3CBBC6: GC_push_roots (in ./my-application)
==4364== by 0x3C8936: GC_mark_some (in ./my-application)
==4364== by 0x3C1C4C: GC_stopped_mark (in ./my-application)
==4364== by 0x3C1AF6: GC_try_to_collect_inner (in ./my-application)
==4364== by 0x3CCAFE: GC_init (in ./my-application)
==4364== by 0x1D47A2: *GC::init:Nil (boehm.cr:127)
==4364== by 0x3C12C3: *Crystal::main<Int32, Pointer(Pointer(UInt8))>:Int32 (main.cr:35)
==4364== by 0x196735: main (main.cr:114)
==4364==
{
<insert_a_suppression_name_here>
Memcheck:Cond
fun:GC_push_all_eager
fun:GC_with_callee_saves_pushed
fun:GC_push_roots
fun:GC_mark_some
fun:GC_stopped_mark
fun:GC_try_to_collect_inner
fun:GC_init
fun:*GC::init:Nil
fun:*Crystal::main<Int32, Pointer(Pointer(UInt8))>:Int32
fun:main
}
In this example, the issued code will suppress a warning for a conditional statement with the described set of function calls.
Just using the code produced as-is is almost useless. This code is way too specific, and chances are that the warnings you want to suppress are related to a particular library, an object file, or to a set of functions with well-formatted names.
To get things right, the code has to be more generic.
As we can see, the suppression code produced by valgrind
will suppress warnings for a kind of memory problem and a specific function stack. To make the code more generic, wildcards can be used to match functions (fun) or object files (obj).
Example:
# This will suppress warnings for this specific stack but the last function on the stack
# could be any function with a name starting with GC_
{
<* wildcard usage>
Memcheck:Cond
fun:GC_*
fun:GC_with_callee_saves_pushed
fun:GC_push_roots
fun:GC_mark_some
fun:GC_stopped_mark
fun:GC_try_to_collect_inner
fun:GC_init
fun:*GC::init:Nil
fun:*Crystal::main<Int32, Pointer(Pointer(UInt8))>:Int32
fun:main
}
For my needs in practice, this is still way too specific.
I don’t want to specify the whole stack. The wildcard “…” should be used.
# This will suppress warnings for any function with a name starting with GC_
# regardless of the function stack.
# This wildcard is combined with *fun* or *obj* selectors (and other wildcards).
{
<... wildcard usage>
Memcheck:Cond
...
fun:GC_*
}
Another example:
# This will suppress warnings for any function in object files /usr/lib/blah*
{
<* wildcard usage with 'obj' instruction>
Memcheck:Cond
...
obj:/usr/lib/blah*
}
As we can see, there is a Memcheck instruction, telling the kind of error produced the warning. These errors can be Cond, Value8, Leak and Addr8. I don’t see a way to combine several kinds of errors into a single instruction.
Take your time. Be sure you don’t suppress useful warnings.
Our suppression code is written in a file, named my-application.suppr for the example.
# valgrind, only with warnings for our code.
$ valgrind --suppressions=my-application.suppr --leak-check=full -v ./my-application
In case there is still useless warnings, just add more instructions. Don’t worry, the process really is straightforward, you will manage. Have fun!
This blog post was heavily inspired by this page.
{
<Garbage Collector>
Memcheck:Cond
...
fun:GC_*
}
{
<Garbage Collector>
Memcheck:Value8
...
fun:GC_*
}
{
<Garbage Collector>
Memcheck:Leak
...
fun:GC_*
}
{
<Garbage Collector>
Memcheck:Addr8
...
fun:GC_*
}
The garbage collector library is written with care, functions start with GC_, very useful to easily match them all. I started with thousands of warnings, it was impossible to find any relevant information in the output. This fixes the problem.
]]>acme-client
and the httpd
server on OpenBSD)opensmtpd
and dovecot
)
example.com
and local usersrspamd
+ Sieve rules to train the antispam)No fancy webmail.
This tutorial is heavily inspired by the vultr tutorial and an old article about let’s encrypt on openbsd.
This is very straightforward.
httpd
has to be configured to point to the right directory for acme challenges for your domainsacme-client
has to know your domainsThat’s it.
httpd.conf
# $OpenBSD: httpd.conf,v 1.20 2018/06/13 15:08:24 reyk Exp $
server "example.com" {
alias "www.example.com"
alias "mail.example.com"
alias "team.example.com"
listen on * port 80
location "/.well-known/acme-challenge/*" {
root "/acme"
request strip 2
}
location "/special/*" {
root "/htdocs/"
}
location * {
block return 302 "https://$HTTP_HOST$REQUEST_URI"
}
}
server "example.com" {
alias "www.example.com"
alias "mail.example.com"
alias "team.example.com"
listen on * tls port 443
root "/htdocs/example.com"
tls {
certificate "/etc/ssl/example.com.fullchain.pem"
key "/etc/ssl/private/example.com.key"
}
location "/pub/*" {
directory auto index
}
location "/.well-known/acme-challenge/*" {
root "/acme"
request strip 2
}
}
acme-client.conf
#
# $OpenBSD: acme-client.conf,v 1.2 2019/06/07 08:08:30 florian Exp $
#
authority letsencrypt {
api url "https://acme-v02.api.letsencrypt.org/directory"
account key "/etc/acme/letsencrypt-privkey.pem"
}
authority letsencrypt-staging {
api url "https://acme-staging-v02.api.letsencrypt.org/directory"
account key "/etc/acme/letsencrypt-staging-privkey.pem"
}
domain example.com {
alternative names { www.example.com mail.example.com team.example.com }
domain key "/etc/ssl/private/example.com.key"
domain full chain certificate "/etc/ssl/example.com.fullchain.pem"
sign with letsencrypt
}
In this example, I want example.com
and three aliases. Here are the DNS records:
example.com IN 1200 A 10.0.0.1
www.example.com IN 1200 A 10.0.0.1
team.example.com IN 1200 A 10.0.0.1
mail.example.com IN 1200 A 10.0.0.1
example.com IN 1200 MX 10 mail
You can also put CNAME
instead of A
records for team
and www
.
You can have free domain names on netlib.re!
Lastly, we want to create acme
and tls
folders:
mkdir /var/www/acme
mkdir -p /etc/ssl/acme/private /etc/acme
chmod 0700 /etc/ssl/acme/private /etc/acme
Then we can restart httpd
and launch acme-client
:
rcctl restart httpd
acme-client example.com
# Second restart, now the web server has the right certificate.
rcctl restart httpd
pkg_add opensmtpd-extras opensmtpd-filter-rspamd dovecot dovecot-pigeonhole rspamd redis
This tutorial uses an user vmail
to handle all virtual users mails. vmail
has the uid 2000
, the gid 2000
, and its home directory will be the root for virtual users maildirs: /var/vmail/
.
touch /etc/mail/credentials
chmod 0440 /etc/mail/credentials
chown _smtpd:_dovecot /etc/mail/credentials
useradd -c "Virtual Users Mail Account" -d /var/vmail -s /sbin/nologin -u 2000 -g =uid -L staff vmail
mkdir /var/vmail
chown vmail:vmail /var/vmail
In our setup, mail users will be either system users or virtual ones. The list of virtual users and their credentials need to be configured: this tutorial use a simple file to that end.
Each client needs to be authenticated before sending emails. Passwords need to be processed before being put in a simple text file.
smtpctl encrypt PASSWORD
# Example: smtpctl encrypt chocolate
# $2b$09$/aUucPECRPTasFpNZcgpEe.0TTSiJ9UXqhF4uIzFvlLr220nBxuMq
This way, passwords can be put in the credentials
file.
The /etc/mail/credentials
file needs to be formatted, almost as /etc/passwd
:
<email>:<password>:<user>:<uid>:<gid>:<maildir-path>::userdb_mail=maildir:<maildir-path>
Parameters user
, uid
and gid
are related to the system user that will handle all virtual users mails: vmail. Also, maildir-path
will be into the vmail
home directory.
Here is an example for the user joe.satriani
for the domain example.com
.
joe.satriani@example.com:$2b$09$/aUucPECRPTasFpNZcgpEe.0TTSiJ9UXqhF4uIzFvlLr220nBxuMq:vmail:2000:2000:/var/vmail/example.com/joe.satriani::userdb_mail=maildir:/var/vmail/example.com/joe.satriani
/etc/mail/virtuals
defines the valid email addresses (and aliases) for our default domain example.com
.
abuse@example.com: joe.satriani@example.com
hostmaster@example.com: joe.satriani@example.com
postmaster@example.com: joe.satriani@example.com
webmaster@example.com: joe.satriani@example.com
joe.satriani@example.com: vmail
steve.vai@example.com: vmail
john.petrucci@example.com: vmail
Before presenting the configuration file, here is a quick overview of the smtpd
configuration parameters.
pki
indicates certificate and key paths for a domain.table
references lists:
listen
directive indicates:
pki
to usefilter
executes an application on a mail
action
describes what to do with a message
match
uses an action based on the processed message (origin, destination)
domain_mail
action for emails for the domain example.com
local_mail
action for emails coming from local addressNext step: the configuration file. I allow a machine in my domain (192.168.0.200
) to send emails with this mail server as a relay.
The configuration file I use.
# $OpenBSD: smtpd.conf,v 1.14 2019/11/26 20:14:38 gilles Exp $
# This is the smtpd server system-wide configuration file.
# See smtpd.conf(5) for more information.
pki "mail.example.com" cert "/etc/ssl/example.com.fullchain.pem"
pki "mail.example.com" key "/etc/ssl/private/example.com.key"
table aliases file:/etc/mail/aliases
table credentials passwd:/etc/mail/credentials
table virtuals file:/etc/mail/virtuals
# Filter potential spam with rspamd
filter "rspamd" proc-exec "/usr/local/libexec/smtpd/filter-rspamd"
# To accept external mail, replace with: listen on all
#
#listen on socket
listen on lo0
listen on "192.168.0.100" \
tls pki "mail.example.com" \
hostname "mail.example.com" filter "rspamd"
# Authorize people to send messages from our server
listen on "192.168.0.100" port submission \
tls-require pki "mail.example.com" \
hostname "mail.example.com" \
auth <credentials> filter "rspamd"
# Where to store incoming emails based on the target user.
action "local_mail" mbox alias <aliases>
action "domain_mail" \
maildir "/var/vmail/example.com/%{dest.user}" \
virtual <virtuals>
# Relay mails when they come from authorized clients.
action "outbound" relay
# Next, we match incoming emails.
# When the mail comes from any place for our domain, it triggers the "domain_mail" action.
match from any for domain "example.com" action "domain_mail"
# When the mail comes from and for a local user it triggers the "local_mail" action.
match from local for local action "local_mail"
# HEADS UP: Authorize forwarding emails for a local machine
match from src "192.168.0.200" for any action "outbound"
# HEADS UP: Authorize forwarding emails for a local machine
match from local for any action "outbound"
match auth from any for any action "outbound"
The setup is simple: smtpd
listens to local connections (on lo0
) and on another interface (with the IP address 192.168.0.100
). TLS is used along with the mail.example.com
PKI for incoming connections (either for submissions or not). Incoming connections are filtered with rspamd
and have mail.example.com
as the provided host name. Submissions need to pass authentication based on the /etc/mail/credentials
file set earlier.
This configuration allows any local or authenticated user to send mails to any domain. Besides the generic configuration in my setup, I authorized the forwarding of mails coming from a specific IP address in my local network (192.168.0.200
).
# First, try the syntax.
doas smtpd -n
# Then run the service.
doas rcctl restart smtpd
Mails will be transfered in the /var/vmail/example.com/<username>/new
directory.
Since dovecot
opens a lot of files, it is preferable to create a login class for the service.
dovecot:\
:openfiles-cur=1024:\
:openfiles-max=2048:\
:tc=daemon:
# Ensure new login class is taken into account.
cap_mkdb /etc/login.conf
# Change the dovecot login class.
usermod -L dovecot _dovecot
File /etc/dovecot/local.conf
auth_mechanisms = plain
first_valid_uid = 2000
first_valid_gid = 2000
mail_location = maildir:/var/vmail/%d/%n
mail_plugin_dir = /usr/local/lib/dovecot
managesieve_notify_capability = mailto
managesieve_sieve_capability = fileinto reject envelope encoded-character vacation subaddress comparator-i;ascii-numeric relational regex imap4flags copy include variables body enotify environment mailbox date index ihave duplicate mime foreverypart extracttext imapsieve vnd.dovecot.imapsieve
mbox_write_locks = fcntl
mmap_disable = yes
namespace inbox {
inbox = yes
location =
mailbox Archive {
auto = subscribe
special_use = \Archive
}
mailbox Drafts {
auto = subscribe
special_use = \Drafts
}
mailbox Junk {
auto = subscribe
special_use = \Junk
}
mailbox Sent {
auto = subscribe
special_use = \Sent
}
mailbox Trash {
auto = subscribe
special_use = \Trash
}
prefix =
}
passdb {
args = scheme=CRYPT username_format=%u /etc/mail/credentials
driver = passwd-file
name =
}
plugin {
imapsieve_mailbox1_before = file:/usr/local/lib/dovecot/sieve/report-spam.sieve
imapsieve_mailbox1_causes = COPY
imapsieve_mailbox1_name = Junk
imapsieve_mailbox2_before = file:/usr/local/lib/dovecot/sieve/report-ham.sieve
imapsieve_mailbox2_causes = COPY
imapsieve_mailbox2_from = Junk
imapsieve_mailbox2_name = *
sieve = file:~/sieve;active=~/.dovecot.sieve
sieve_global_extensions = +vnd.dovecot.pipe +vnd.dovecot.environment
sieve_pipe_bin_dir = /usr/local/lib/dovecot/sieve
sieve_plugins = sieve_imapsieve sieve_extprograms
}
protocols = imap sieve
service imap-login {
inet_listener imaps {
port = 993
}
}
service managesieve-login {
inet_listener sieve {
port = 4190
}
inet_listener sieve_deprecated {
port = 2000
}
}
ssl_cert = </etc/ssl/example.com.fullchain.pem
ssl_key = </etc/ssl/private/example.com.key
userdb {
args = username_format=%u /etc/mail/credentials
driver = passwd-file
name =
}
protocol imap {
mail_plugins = " imap_sieve"
}
As of today (september 2020), there still is a bug in Dovecot: the ssl_cert
and ssl_key
settings do not get overridden in the local.conf
file. We need to so we have to comment these parameters in the file /etc/dovecot/conf.d/10-ssl.conf
.
To train rspamd
, we need to provide sieve scripts. Training is done by moving emails into and out the junk folder. These files are located at /usr/local/lib/dovecot/sieve
.
This archive contains the 4 files you need:
report-ham.sieve
and report-spam.sieve
sa-learn-ham.sh
and sa-learn-spam.sh
Once untar in /usr/local/lib/dovecot/sieve
:
sievec report-ham.sieve
sievec report-spam.sieve
chmod 0755 sa-learn-ham.sh
chmod 0755 sa-learn-spam.sh
Then we can start the dovecot
daemon.
rcctl enable dovecot
rcctl start dovecot
Finally, we can verify the setup by requesting informations about a client.
doveadm user joe.satriani@example.com
And verify that the user can log in.
doveadm auth login joe.satriani@example.com
For rspamd
, we need:
doas su
mkdir /etc/mail/dkim
cd /etc/mail/dkim
openssl genrsa -out private.key 1024
openssl rsa -in private.key -pubout -out public.key
chmod 0440 private.key
chown root:_rspamd private.key
Of course, you have to put your own public IPv4 (or IPv6) address.
example.com. IN TXT "v=spf1 a ip4:192.168.0.100 mx ~all"
default._domainkey.example.com. IN TXT "v=DKIM1;k=rsa;p=[…public key…]"
_dmarc.example.com. IN TXT "v=DMARC1;p=none;pct=100;rua=mailto:postmaster@example.com"
Then we need to create the /etc/rspamd/local.d/dkim_signing.conf
file.
domain {
example.com {
path = "/etc/mail/dkim/private.key";
selector = "default";
}
}
Now, we have all the scripts, configuration files and services up and running except redis
and rspamd
.
doas rcctl enable redis rspamd
doas rcctl start redis rspamd
I wanted to use the Let’s Encrypt certificate with my Nginx server. This is something really simple in principle. Here’s the catch: if something goes wrong, there is nothing telling you where to search.
First, I got a certificate from Let’s Encrypt. There’s like a billion articles on this subject online, I just used acme.sh
. It works, even if the documentation could be improved.
Just a reminder: DNS management means you’ll have to change things in your DNS each time you will have to renew your certificates.
Nginx is happy: I give it the certificate I got from LE, stored in /root/.acme/ndd/ndd.cer
. When I visit my websites with the different browsers I use, everything is fine.
Problem: git cannot access my website and tells me it can’t verify my certificate.
$ git clone https://example.com/Something/there.git/
Cloning into 'there'...
fatal: unable to access 'https://example.com/Something/there.git/': server certificate verification failed. CAfile: /etc/ssl/certs/ca-certificates.crt CRLfile: none
The problem seems to be that I don’t have on my computer the right certificates for certification authorities. But, actually, I do have them.
So, what’s going on? Git (actually, curl) needs to access an HTTS website, which is perfectly OK on browsers, but tells me it’s not. Who’s lying?
Now, here what I learned the last time I configured my Nginx: you have to provide a full-chained certificate. Nginx is perfectly OK with the one provided by acme.sh
that you find in /root/.acme/ndd/ndd.cer
but it’s actually partial! You only have your certificate, not the intermediary ones.
To get the intermediary certificates, I downloaded them on whatsmychaincert.com. It tests the certificate chain and provide intermediaries if your website doesn’t provide them.
Getting everything working is a piece of cake:
# cat /root/.acme/ndd/ndd.cer chain.cer > full-chained-ndd.cer
That’s great… but I do think this information could have been simpler to solve.
I followed the acme.sh
guide to get a certificate, and I got one. The configuration was OK for nginx, so I didn’t check the guide for a configuration error, since it wasn’t an actual error. Then, I used my browsers and they seem fine. Finally, I got an error from git (and curl), and it wasn’t clear at all.
I searched for hours.
Thanks SSLMate, you did a great job providing an online tool to test this specific problem.
# My very simple tmux configuration file in `~/.tmux.conf`
set-option -g status-position top
set -g status-bg blue
set -g status-left '' # removing the session number
setw -g window-status-current-format '#[fg=colour1,bg=colour11]#I:#W'
karblog=$HOME/repos/blog-karchnu/
dnsblog=$HOME/work/dnsmanager-website/
set -e
# This is the first window, with a default name
tmux rename-window "karchnu's blog"
tmux split-pane -h
tmux select-pane -t 0
tmux send-keys "cd '$karblog' && ./site watch" 'C-m'
tmux select-pane -t 1
tmux send-keys "cd '$karblog'" 'C-m'
tmux new-window -n "dnsmanager website"
tmux split-pane -h
tmux select-pane -t 0
tmux send-keys "cd '$dnsblog' && start-zola.sh" 'C-m'
tmux select-pane -t 1
tmux send-keys "cd '$dnsblog'" 'C-m'
tmux source-file ~/.tmux.conf
Or through the tmux
build-in cli: ^: source-file ~/.tmux.conf
Petit mémo.
La configuration des certificats Prosody est simple. Il faut en premier récupérer un certificat LE, peu importe comment (par exemple avec acme.sh).
Ensuite, on copie les fichiers (et on en renomme un) comme suit :
cp /etc/ssl/le/chained-domain.pem /var/prosody/domain.crt
cp /etc/ssl/le/chained-domain.key /var/prosody/domain.key
chown _prosody:_prosody domain.*
prosody restart
Here is the configuration I performed on my OpenBSD desktop workstation. I wanted:
Xenodm
is used to launch the X server, a graphical login prompt then the window manager.
rcctl enable xenodm
rcctl start xenodm
I use daily the awesome window manager, and I want it on my OpenBSD (I want some tiling!). Xenodm uses the file ~/.xsession
to know what program we want for the X session. The simplest way to tell xenodm to launch awesome is:
echo exec awesome >> ~/.xsession
OpenBSD ships an example of the user’s rc configuration file in /usr/local/share/examples/awesome/rc.lua
, and I use it almost as is. The only thing I want to change are the title bars on top of each window. I do not want them. There’re useless as fuck. The whole point of having a tiling window manager is to never have to manually change a window size, so this title bar takes space on my screen for no reason! Here is the quick change I made to the configuration example:
-- In the file `~/.config/awesome/rc.lua`, copied from `/usr/local/share/examples/awesome/rc.lua`
...
-- Add titlebars to normal clients and dialogs
{ rule_any = {type = { "normal", "dialog" }
}, properties = { titlebars_enabled = true } -- CHANGE TO "false" to remove useless bars!
},
...
For testing, you can manually configure your the wireless card:
ifconfig iwn0 nwid YOUR_SSID wpakey "YOUR_PASSPHRASE"
dhclient iwn0
When you move, you want to connect automatically to the nearest WiFi hotspot you know.
# In the file `/etc/hostname.if` (in my case: `/etc/hostname.iwm0`)
join "SSID" wpakey "KEY"
# join "another SSID" wpakey "another KEY"
# join "again" wpakey "some more KEY"
dhcp
up powersave
For the installation, I also used a wired connection and I need static configuration for my virtual machines. Here is an example:
# In the file `/etc/hostname.em0`
inet 192.168.42.2 255.255.255.0
This line can be replaced by “dhcp”. We can add “up” in the file if we want this device to be started on system boot.
Once we put a network interface up, a script can be started:
!/path/to/my/script
As an example, I use this on another installation to start a VPN connection to my ISP:
# In the file `/etc/hostname.tun0`
description "OpenVPN client to ARN server"
!/usr/local/sbin/openvpn --daemon --config /etc/openvpn/openvpn.conf --dev $if & false
up
I really like Fira Code
fonts, and want them for development.
# Fira Code fonts installation
mkdir ~/.local/share/fonts ; cd ~/.local/share/fonts
git clone https://github.com/tonsky/FiraCode ; fc-cache -vf
The terminal I’m currently using is Konsole, but I’m not quite satisfied at the moment. Yes, it behaves smoothly with ligatured fonts, but it is kinda heavy. I would prefer something way simpler and faster to boot, such as Kitty or Alacrity (which are either not supported on OpenBSD or do not support ligatures).
On Konsole
, I currently use the Breeze
theme, with Fira Code Medium, font size 12, 10.000 lines of backlog (but without the scrolling bar, since it takes space for nothing), with the UTF-8 encoding (I need french accents!). A shortcut I use: CTRL + SHIFT + M
(removes the navigation bar).
There are two ways to get the Crystal language working on my OpenBSD laptop:
These two points deserve an article on their own.
The default modesetting driver doesn’t use vsync, so you’ll get a lot of tearing when scrolling webpages or watching videos. If you have an Intel-based video chipset, you can switch to the intel driver to get smooth video. – Callum Smith on his blog
Since I have an Intel graphic card, I do need some more configuration for the X server. First, mkdir /etc/X11/xorg.conf.d/
, then:
# In the file `/etc/X11/xorg.conf.d/intel.conf`
Section "Device"
Identifier "drm"
Driver "intel"
Option "TearFree" "true"
EndSection
OpenBSD ships with drastic restrictions for the user, I want to alleviate this so we can use poorly designed software and protocols (yes, I talk about the web: web protocols, web browsers and so).
# In the file `/etc/sysctl.conf`
# to allow the openbsd box to perform router's tasks
net.inet.ip.forwarding=1
# shared memory limits (chrome needs a ton)
kern.shminfo.shmall=3145728
kern.shminfo.shmmax=2147483647
kern.shminfo.shmmni=1024
# semaphores
kern.shminfo.shmseg=1024
kern.seminfo.semmns=4096
kern.seminfo.semmni=1024
kern.maxproc=32768
kern.maxfiles=65535
kern.bufcachepercent=90
kern.maxvnodes=262144
kern.somaxconn=2048
I put my user in the staff
login class with usermod -L staff karchnu
, then I changed the default configuration to allow more resources.
# In the file `/etc/login.conf`
# Staff have fewer restrictions and can login even when nologins are set.
staff:\
:datasize-cur=7000M:\
:datasize-max=infinity:\
:maxproc-max=512:\
:maxproc-cur=256:\
:ignorenologin:\
:requirehome@:\
:tc=default:
I want my user to be able to halt and reboot the laptop. I also want to control the virtual machines without entering any password, for vmctl
or qemu
.
permit nopass karchnu as root cmd vmctl
permit nopass karchnu as root cmd halt
permit nopass karchnu as root cmd reboot
permit nopass karchnu as root cmd /usr/local/bin/qemu-system-x86_64
To have greater disk performances, we can allow [soft updates][softupdates] (softdep option) and the noatime
option on our partitions.
# In the file `/etc/fstab`
MYUUID.b none swap sw
MYUUID.a / ffs rw,softdep,noatime, 1 1
MYUUID.k /home ffs rw,softdep,noatime,nodev,nosuid 1 2
MYUUID.d /tmp ffs rw,softdep,noatime,nodev,nosuid 1 2
MYUUID.f /usr ffs rw,softdep,noatime,nodev 1 2
MYUUID.g /usr/X11R6 ffs rw,softdep,noatime,nodev 1 2
MYUUID.h /usr/local ffs rw,wxallowed,softdep,noatime,nodev 1 2
MYUUID.j /usr/obj ffs rw,nodev,softdep,noatime,nosuid 1 2
MYUUID.i /usr/src ffs rw,nodev,softdep,noatime,nosuid 1 2
MYUUID.e /var ffs rw,nodev,softdep,noatime,nosuid 1 2
mkdir /etc/apm/
There are two lines to put in the file /etc/apm/suspend
:
#!/bin/sh
pkill -USR1 xidle
sed -i 's/xconsole/#xconsole/' /etc/X11/xenodm/Xsetup_0
echo 'xset b off' >> /etc/X11/xenodm/Xsetup_0
# In the file `/etc/wsconsctl.conf`
keyboard.bell.volume=0
pkg_add vim moc gnuwatch firefox chromium mplayer konsole qemu
# unfortunately `moc` cannot change audio settings on its own, we have to use `mixerctl`
# which is not a deal-breaker
alsamixer
(+ pulseaudio and other stuff) => mixerctl
+ audioctl
sysctl
or wsconsctl
, providing a great feeling of consistencyacpi
=> apm -l
systemctl
=> rcctl
(same functionalities but without the bloat)journalctl
=> /var/log
(all we ever needed, for fuck’s sake)The good part. I got most of what I wanted working without any trouble. The desktop installation was smooth, so were the audio and the network. Nothing to say, it was just working out-of-the-box, even better than expected!
The documentation is near perfect. A good part of this article is documented in the OpenBSD FAQ, which helps you get most of the things working. Also, there are tons of examples, such as complete configuration files in /etc/examples
or /usr/local/share/examples/
, which are very useful when you want things done quick. You have some documentation in /usr/local/share/doc/
for third party software, and there are often examples in manuals. It’s so great that I read documentation for fun.
The system is clean: directories have a well-defined purpose, and it’s easy to find the right one. Here some examples of useful directories to know:
/usr/local/share/doc/pkg-readmes/
/usr/lib
or /usr/local/lib
and that’s it, no bloat/usr/ports/infrastructure/bin/
Also, there is a real consistency in the directories usage. For anyone used to Debian absurdities, that’s a blessing.
The tooling on this system is also very interesting and complete, you rarely need anything more than what’s already provided to work on the system. By pure random chance, I read the proot(1 manual. This program allows you to create chroot
environments based solely on file hard links of your host system. In other words, you can create living systems in chroot
environments without using anymore space on your disk (just some more inodes), with a simple command, and without requiring shiny file systems nor fancy virtual machines. This is useful for building or packaging applications without installing anything on your host. This tool is so simple that I might develop something similar on Linux (I need something like this for a future project, stay on). No wonder all OpenBSD developers do not rush to get virtual machines working, there is simply no need, really.
The less good part. I got some problems installing an Alpine virtual machine, and I will describe this in another article. Just a word on this issue: Alpine virtual machines can randomly crash using vmm
, but most of the work is done. OpenBSD virtual machines work smoothly. Qemu
under OpenBSD seems slow, but it is stable (I got Alpine working perfectly).
I would like to have a terminal emulator such as Kitty running on OpenBSD, to remove all the GUI bloat from Konsole, but it’s not yet possible. However, it’s not a problem related by OpenBSD itself, just the lack of support for very recent projects.
Finally, I think that I had a great experience. Some things will be even better in a near future with the efforts put on vmm
. I do hope that someone will port the Crystal compiler on OpenBSD soon, I’ll do it myself otherwise.
I was inspired by some articles and documentations.
Le monde d’Arduino est merveilleux, avec des gens gentils qui répondent à toutes vos questions, avec un site où tout est bien écrit comme il faut, où tout est à jour et quoi que vous souhaitiez faire devient simple grâce aux fabuleuses documentations en ligne !
… c’est ce que j’aurais aimé me dire en démarrant mon petit projet, mais on est loin de la réalité.
J’ai un Zigduino, un module “Ethernet Shield 2”, et un mal fou pour faire fonctionner tout ça, donc voici un récapitulatif de ce qu’il faut faire pour réussir à lancer ne serait-ce que les sketchs d’exemple.
En premier, on télécharge les bibliothèques arduino ainsi que les fichiers zigduino (pour indiquer des paramètres liés à cette plateforme spécifique, les pins, etc).
zigduinopath=~/zigduino
arduinopath=~/arduino
git clone https://github.com/logos-electromechanical/Zigduino-1.0 $zigduinopath
wget https://downloads.arduino.cc/arduino-1.8.5-linux64.tar.xz && tar xf arduino-1.8.5-linux64.tar.xz && mv arduino-1.8.5 $arduinopath
# on n'a plus besoin de ce fichier là, on va le remplacer
mv $arduinopath/hardware/arduino/avr/boards.txt $arduinopath/hardware/arduino/avr/boards.txt.000
# série de lien symboliques pour indiquer à Arduino qu'on gère une autre plateforme
ln -s $zigduinopath/hardware/arduino/cores/zigduino $arduinopath/hardware/arduino/avr/cores/
ln -s $zigduinopath/hardware/arduino/boards.txt $arduinopath/hardware/arduino/avr/
ln -s $zigduinopath/hardware/arduino/variants/zigduino_r2/ $arduinopath/hardware/arduino/avr/variants/
Maintenant nous avons les fichiers Arduino (avec les bibliothèques) et les fichiers liés à la plateforme Zigduino, il nous faut les fichiers spécifiques pour le module Ethernet 2. Oui hein, bien que ça fasse des années que le module est sorti (aux alentours de 2015?), ils allaient pas l’inclure dans les bibliothèques fournies de base !
git clone https://github.com/adafruit/Ethernet2.git $arduinopath/librairies/
Fantastique. Maintenant on s’occupe de compiler nos programmes, et les makefile sont faits pour ça. Il existe un makefile parfait pour gérer les projets Arduino : Arduino mk.
arduinomk=~/arduinomk
git clone git@github.com:sudar/Arduino-Makefile.git $arduinomk
Pour finir, il faut indiquer dans les makefile de nos projets qu’il faut les étendre avec le makefile d’Arduino, et indiquer quelques paramètres comme la plateforme à utiliser, où se trouvent les bibliothèques et quelles sont les bibliothèques que nous souhaitons inclure, où se trouvent les bibliothèques de l’utilisateur, etc. Donc nous allons au plus simple :
ARDMK_DIR = ~/arduinomk
ARDUINO_DIR = ~/arduino
AVR_TOOLS_DIR = $(ARDUINO_DIR)/hardware/tools/avr
USER_LIB_PATH = $(realpath ../../libraries) # all my libs here
TARGET = .
#### For Zigduino r2 platform and 802.15.4
BOARD_TAG = zigduino_r2
ARDUINO_CORE_PATH = $(ARDUINO_DIR)/hardware/arduino/avr/cores/zigduino
MONITOR_PORT ?= /dev/ttyUSB0
ARDUINO_LIBS = SPI Ethernet2 # and yours ;)
include $(ARDMK_DIR)/Arduino.mk
CPPFLAGS += -Wall -std=c++11
CPPFLAGS += -D__ARDUINO_BUILD
CPPFLAGS += -U__PROG_TYPES_COMPAT__
testcflags:
echo $(CPPFLAGS)
test : all upload monitor
retest: reset monitor
Et voilà, vous pouvez compiler… et voir qu’il y a deux belles erreurs, liées aux fichiers Zigduino qui n’ont pas tout ce qu’il faut. Déjà, il faut créer une fonction inutile (fonction yield
totalement vide) histoire que la compilation se fasse bien.
Fichier $arduinopath/hardware/arduino/cores/zigduino/Arduino.h
void yield (void);
Fichier $arduinopath/hardware/arduino/cores/zigduino/Arduino.cpp
void yield (void) {}
Voilà voilà voilà… et on va dé-commenter une ligne dans le fichier $arduinopath/hardware/arduino/variants/zigduino_r2/pins_arduino.h
, voici un petit diff :
-/*const static uint8_t SS = 10*/
+const static uint8_t SS = 10;
Comme on peut le voir, c’est une ligne qui existait déjà, mais que les développeurs ont cru bon de commenter… et pour finir il faut remplacer Ethernet.h
par Ethernet2.h
et EthernetUdp.h
par EthernetUdp2.h
dans nos programmes et voilà, on peut compiler nos fichiers d’exemple ! Youhou !
Arduino is so fantastic!
… hell no. Here is the truth when you try to use Zigduino and the Ethernet Shield 2.
First, we download Arduino libraries and zigduino files (platform-specific parameters, such as pin numbers, that sort of stuff).
zigduinopath=~/zigduino
arduinopath=~/arduino
git clone https://github.com/logos-electromechanical/Zigduino-1.0 $zigduinopath
wget https://downloads.arduino.cc/arduino-1.8.5-linux64.tar.xz && tar xf arduino-1.8.5-linux64.tar.xz && mv arduino-1.8.5 $arduinopath
# we do not need this file anymore, we will replace it
mv $arduinopath/hardware/arduino/avr/boards.txt $arduinopath/hardware/arduino/avr/boards.txt.000
# symbolic links, to handle a new platform
ln -s $zigduinopath/hardware/arduino/cores/zigduino $arduinopath/hardware/arduino/avr/cores/
ln -s $zigduinopath/hardware/arduino/boards.txt $arduinopath/hardware/arduino/avr/
ln -s $zigduinopath/hardware/arduino/variants/zigduino_r2/ $arduinopath/hardware/arduino/avr/variants/
Now we need the Ethernet shield 2 libraries, because guess what, they are not shipped with the arduino libraries for some reason, even if the module was released years ago (circa 2015).
git clone https://github.com/adafruit/Ethernet2.git $arduinopath/librairies/
Fantastic. Now we try to compile our programs, and makefiles are the way to do it. There is a dedicated project for that: Arduino mk.
arduinomk=~/arduinomk
git clone git@github.com:sudar/Arduino-Makefile.git $arduinomk
To finish, we need to tell our program makefile to extend itself with the arduino mk one, and give some parameters such as the platform to use, where the libraries are (and the ones we want to use), where the user libraries are, etc. The simplest way:
ARDMK_DIR = ~/arduinomk
ARDUINO_DIR = ~/arduino
AVR_TOOLS_DIR = $(ARDUINO_DIR)/hardware/tools/avr
USER_LIB_PATH = $(realpath ../../libraries) # all my libs here
TARGET = .
#### For Zigduino r2 platform and 802.15.4
BOARD_TAG = zigduino_r2
ARDUINO_CORE_PATH = $(ARDUINO_DIR)/hardware/arduino/avr/cores/zigduino
MONITOR_PORT ?= /dev/ttyUSB0
ARDUINO_LIBS = SPI Ethernet2 # and yours ;)
include $(ARDMK_DIR)/Arduino.mk
CPPFLAGS += -Wall -std=c++11
CPPFLAGS += -D__ARDUINO_BUILD
CPPFLAGS += -U__PROG_TYPES_COMPAT__
testcflags:
echo $(CPPFLAGS)
test : all upload monitor
retest: reset monitor
Et voilà ! Now you can compile… and see by yourself two ugly errors.
Let’s fix this. First, we need to create a totally useless function yield
.
File $arduinopath/hardware/arduino/cores/zigduino/Arduino.h
void yield (void);
File $arduinopath/hardware/arduino/cores/zigduino/Arduino.cpp
void yield (void) {}
No comment.
Also, we have to uncomment a line in the file $arduinopath/hardware/arduino/variants/zigduino_r2/pins_arduino.h
, there a little diff:
-/*const static uint8_t SS = 10*/
+const static uint8_t SS = 10;
As we can see, this is a line that was already there, but developers guessed that this should be commented for some reason… Don’t forget to replace Ethernet.h
by Ethernet2.h
and EthernetUdp.h
by EthernetUdp2.h
… THEN we can compile our programs! Hooray!
Je souhaite économiser un peu d’énergie sur ma machine. Le plus simple pour économiser de l’énergie est de gérer la fréquence du processeur pour qu’elle soit minimale. Pour gérer la fréquence du processeur, nous avons le démon apmd
(sous OpenBSD).
Nous avons 3 étapes à faire pour économiser de l’énergie durablement : activer apmd
au démarrage, lui dire de se mettre en économie d’énergie (fréquence processeur la plus basse possible), et enfin le démarrer pour notre session actuelle.
rcctl enable apmd
rcctl set apmd flags "-L"
rcctl start apmd
Après dans mon BIOS je peux désactiver des cœurs, modifier le voltage de mon CPU et quelques joyeusetés de ce style. C’est également à essayer pour économiser encore plus : je n’ai pas besoin de 4 cœurs pour gérer quelques services à la maison, et le processeur que j’ai est clairement surpuissant par rapport au besoin.
]]>Ma famille est sous GNU/Linux (ouais, pas encore OpenBSD, un jour peut-être). Je veux pouvoir me connecter sur leur ordinateur dès qu’il est connecté au net pour pouvoir les dépanner.
Je pars du principe que ma famille n’a pas de nom de domaine, une IP qui peut changer, et je ne veux pas non plus qu’ils aient à lancer une application. L’idée est d’être autonome, ne pas dépendre d’eux pour le dépannage, et accessoirement qu’ils n’aient pas à apprendre ou faire quoi que ce soit.
Plusieurs solutions sont possibles : VNC (graphique et donc lent car la connexion est mauvaise), des trucs privateurs ressemblant à VNC (ce qui revient au même et en plus c’est pas libre), ou alors un bon vieux SSH qui marche bien.
Va pour SSH ! Il existe d’ailleurs un programme nommé “autossh” mais que je n’utilise pas (j’ai un script perso qui fonctionne bien).
L’idée est de créer un tunnel SSH de chez moi à chez eux sur leur port 22. Leur machine se connecte chez moi, crée le tunnel, ouvre un port sur mon serveur qui pointe vers le port 22 de leur machine. Ce qu’il faut donc faire :
Sur leur machine :
useradd _autossh
/usr/local/bin/
/home/_autossh/
, modifiez la configuration si vous voulez l’utiliser ;)/usr/local/bin/
pour tester la configurationchown _autossh:_autossh /usr/local/bin/autossh*
puis chmod 500 /usr/local/bin/autossh*
su - _autossh ; ssh-keygen -t ed25519
Sur notre serveur :
~/.ssh/id_ed25519.pub
de l’utilisateur _autossh de leur machine dans le fichier ~/.ssh/authorized_keys
de l’utilisateur acceptant la connexion sur le serveurEnsuite il faut que _autossh
se connecte une fois à notre serveur afin qu’il connaisse la clé d’identification et accepte de s’y connecter automatiquement par après. Et enfin on active notre crontab sur leur machine :
*/5 * * * * bash /usr/local/bin/autossh-connection.sh
Voilà !
Maintenant on veut pouvoir se connecter chez la famille depuis son ordinateur. L’idée est d’avoir une fonction shell qui s’occupe de créer un tunnel vers notre serveur puis nous connecte à leur machine en passant par les 2 tunnels.
Admettons que la machine familliale ouvre le port 6000 sur notre serveur pour le tunnel, nous allons nous y connecter de cette manière :
function connexionParents()
{
ssh -NTL 6000:localhost:6000 karchnu.fr & # tunnel entre notre ordinateur et notre serveur
X=$! # sauvegarde du PID du tunnel
sleep 10 # on attend que le tunnel soit en place...
ssh -p 6000 root@localhost # connexion à la machine familliale (via les tunnels)
kill $X # on arrête le tunnel une fois la connexion close
}
L’association Alsace Réseau Neutre fournit des machines virtuelles avec le système d’exploitation de notre choix. C’est tout naturellement que les gens intéressants, cultivés et qui sentent bon choisissent OpenBSD comme système.
La configuration réseau de l’association est particulière, puisqu’elle implique d’avoir une IP de passerelle… mais pas d’adresse hôte par machine virtuelle dans sa plage ! Il faut donc mettre une route par défaut vers une “passerelle” en indiquant directement l’interface réseau à utiliser.
Sous OpenBSD, la configuration réseau se passe dans 2 fichiers :
/etc/hostname.iface
pour indiquer les IP de la machine (/etc/hostname.vio0
dans notre cas)/etc/mygate
pour indiquer la passerelle (v4 et v6)Donc, dans notre fichier /etc/hostname.vio0
:
inet alias <votre_IPv4> 255.255.255.255
!route -n add -host 169.254.42.1 -llinfo -link -static -iface vio0
inet6 <une_IPv6_dans_votre_bloc_IPv6> 56
Dans le fichier /etc/mygate
:
169.254.42.1
fe80::42:1%vio0
Les adresses en dur sont liées à la configuration interne du routage d’Alsace Réseau Neutre.
C’est beau. ♥
(Est-ce que j’ai dit à quel point c’est moins joli sous Linux ? Allez vous faire votre propre avis.)
]]>J’ai récemment voulu héberger un mediawiki sur mes serveurs openbsd, voici un résumé des étapes.
Les outils utilisés :
Installation des programmes qu’il faut :
pkg_add php56_fpm nginx mariadb-server
Premièrement, la configuration du serveur web nginx : pour l’instant sans la partie sécurisée.
# nginx, changer "domain" par votre nom de domaine
server {
listen 80;
listen [::]:80;
server_name domain www.domain;
location /.well-known/acme-challenge {
alias /htdocs/challenges/;
location ~ /.well-known/acme-challenge/(.*) {
add_header Content-Type application/jose+json;
}
}
location / {
rewrite ^ https://domain$request_uri? permanent;
}
}
Nginx est mis en chroot
, donc les programmes n’ont pas accès à la résolution de noms si le fichier resolv.conf
n’est pas copié dans le chroot.
mkdir /var/www/etc/
cp /etc/resolv.conf /var/www/etc/
Let’s encrypt : téléchargement d’un programme qui permet de faire signer notre certificat.
# changez partout "domain" par votre nom de domaine
cd /etc/ssl/
git clone https://github.com/diafygi/acme-tiny.git
# création d'une clé de compte
openssl genrsa 4096 > account.key
# générer une clé de domaine
openssl genrsa 4096 > domain.key
# pour un seul domaine
openssl req -new -sha256 -key domain.key -subj "/CN=domain" > domain.csr
# répertoire où se trouveront les fichiers de test
mkdir /var/www/htdocs/challenges
#run the script on your server
python3.5 acme_tiny.py --account-key ./account.key --csr ./domain.csr --acme-dir /var/www/htdocs/challenges/ > ./signed.crt
wget -O - https://letsencrypt.org/certs/lets-encrypt-x3-cross-signed.pem > intermediate.pem
cat signed.crt intermediate.pem > chained-domain.pem
rcctl restart nginx
La partie sécurisée de la configuration de nginx, maintenant qu’on a notre certificat ça va bien se passer.
# nginx, changer "domain" par votre nom de domaine
server {
listen 443;
listen [::]:443;
server_name domain www.domain;
root /var/www/htdocs/domain/;
index index.php index.html;
ssl on;
ssl_certificate /etc/ssl/le/chained-domain.pem;
ssl_certificate_key /etc/ssl/le/domain.key;
ssl_session_timeout 5m;
ssl_session_cache shared:SSL:1m;
ssl_ciphers HIGH:!aNULL:!MD5:!RC4;
ssl_prefer_server_ciphers on;
location / {
root /var/www/htdocs/domain/;
}
location ~ \.php$ {
try_files $uri $uri/ =404;
fastcgi_pass unix:/run/php-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
location /.well-known/acme-challenge {
alias /htdocs/challenges/;
location ~ /.well-known/acme-challenge/(.*) {
add_header Content-Type application/jose+json;
}
}
}
Configuration de php : on rajoute des extensions pour mediawiki et on ajoute des lignes dans le fichier /etc/php-5.6.ini
.
# installation de bibliothèques pour PHP
pkg_add php-gd-5.6 php-intl php-xcache
# fichier /etc/php-5.6.ini
extension=curl.so
extension=gd.so
extension=intl.so
extension=mysql.so
# redémarrer PHP FPM
rcctl restart php56_fpm
# vérifier les extensions disponibles, voir si ça a été pris en compte
php-5.6 -m
Les modules installés se trouvent dans /usr/local/lib/php-5.6/modules/intl.so
.
Ensuite, j’ai voulu installer un mariadb, pour ça j’ai simplement suivi mes propres conseils de la page dédiée à l’installation d’un mysql, cette fois en changeant mysql-server
par mariadb-server
.
Ensuite, quelques commandes pour mettre en place la BDD telle qu’on la voudrait :
# le % est là pour indiquer que cet utilisateur peut se connecter à partir de n'importe-quelle adresse IP
# mettre "localhost" si votre sgbd est sur la même machine que le serveur web
create database dbname;
create user username@"%";
set password for username@"%" = password('your-password');
grant all on username.* to dbname@"%";
Enfin, si votre sgbd est sur une autre machine, il faut qu’il accepte les connexions non locales. Pour ça on va dans le fichier /etc/my.cnf
et on modifie la ligne bind-address
par :
bind-address = 0.0.0.0
Ensuite, pour mettre à jour les certificats, je me suis fait un script que j’ai mis dans /etc/ssl/le/renew-certs.sh
:
#!/usr/bin/sh
DOMAIN=$1
LEDIR=/etc/ssl/le
ACMEDIR=/var/www/htdocs/challenges
python3.5 ./acme-tiny/acme_tiny.py --account-key $LEDIR/account.key --csr $LEDIR/$DOMAIN.csr --acme-dir $ACMEDIR > tmpsigned.crt || exit
ftp -o intermediate.pem https://letsencrypt.org/certs/lets-encrypt-x3-cross-signed.pem
cat tmpsigned.crt intermediate.pem > $LEDIR/chained-$DOMAIN.pem
rm tmpsigned.crt
Puis un script que j’ai placé dans /usr/local/bin/update-domain-certs
pour lancer mes autres scripts.
# /usr/local/bin/update-domain-certs
#!/bin/sh
LEDIR=/etc/ssl/le
cd $LEDIR || exit 1
sh ./renew-certs.sh domain1 || exit 2
sh ./renew-certs.sh domain2 || exit 2
# ...
Pour lancer le script précédent, les droits de l’utilisateur www
suffisent, donc on configure doas :
# /etc/doas.conf
permit nopass keepenv root as www cmd /usr/local/bin/update-domain-certs
Et pour que ça se fasse tous les mois (donc largement avant la limite des 90 jours pour l’expiration des certificats let’s encrypt), il suffit de faire appel à cron :
# fichier /etc/monthly.local
doas -u www /usr/local/bin/update-domain-certs && rcctl reload nginx
Je ne détaille pas l’installation de mediawiki, je pense qu’il n’y a pas grand chose à dire. Le site est à mettre dans le répertoire /var/www/htdocs/domain/
.
Pour conclure je dirais que vivement que httpd gère SNI. La configuration devrait être encore plus légère et simple côté serveur web, et je serai un peu plus confiant puisque le développement est fait par des gens d’openbsd. fanboy detected.
]]>Pour faire du multiarch sur debian, par exemple pour utiliser des binaires 32 bits sur un système 64 bits, il faut activer l’architecture avec dpkg puis modifier les dépôts pour télécharger la liste des paquets des architectures choisies.
dpkg --add-architecture <arch>
Fichier /etc/apt/sources.list :
deb [arch=amd64,i386] http://ftp.fr.debian.org/debian/ stable contrib
# update
apt-get update
Ensuite pour télécharger un paquet de l’architecture choisie :
apt-get install <paquet>:<arch>
Pour les détails et pour aller plus loin : voir le site de Debian.
]]>J’ai cherché un programme qui permettait de récupérer la couleur d’un pixel sous linux, et me redonner sa valeur en RGB hexadécimal. Ce programme existe et s’appelle gcolor2
. C’est pratique, pour faire des présentations.
J’ai cherché un programme qui permettait de connaître la taille d’un fichier binaire (.text, .bss, .data…). Ce programme existe sous linux est s’appelle tout simplement size
.
# taille d'un fichier binaire
size elf-binary
Et pour connaître dans le détail le contenu du binaire (format ELF) : readelf
. J’aurais aimé trouver ça plus tôt !
Un logiciel simple, stable, qui marche et qui fait juste ce que je veux pour faire des schéma : xfig
. Ce soft est vieux et utilise directement les appels à X pour la partie graphique, donc c’est moche, mais il est bien.
# installation xfig sur ubuntu
sudo apt-get install xfig xfonts-utils xfonts-base xfonts-encodings gsfonts-x11
On redémarre X pour avoir les fonts qui marchent bien, puis c’est tout facilement gérable pour faire des jolis schéma.
Pour avoir des accents, il faudra passer par man latin9
et aller dans les fichiers .fig
pour mettre les caractères, comme \351
pour faire un é
.
L’aspect vraiment pratique à part que ce soit simple à utiliser, c’est le format extrèmement simple du fichier généré.
]]>L’installation d’un serveur XMPP est super simple, même sur OpenBSD.
pkg_add prosody
Dans /etc/prosody/prosody.rc.lua
il faut aller décommenter l’option “posix” sinon le démon ne démarre pas. Ensuite on peut générer un certificat facilement avec prosodyctl :
prosodyctl cert generate nom-de-domaine.tld
Et enfin ajouter sa configuration pour un nouveau nom de domaine (= recopier la configuration de “example.com”) puis démarrer prosody :
prosodyctl start
# ou
/etc/rc.d/prosody start
Ensuite je n’ai pas envie de laisser des gens créer des comptes sur mon serveur, je tiens à rester maître à bord et créer les comptes au compte goutte. Je n’active pas le module en question, et je me crée un compte :
prosodyctl adduser user@nom-de-domaine.tld
Enjoy !
]]>Je me suis retrouvé avec l’erreur could not open port /dev/ttyUSB0: [Errno 13] Permission denied:
. La solution à ça est de se mettre dans le groupe dialout
.
Ajout d’un utilisateur dans le groupe dialout
usermod -aG dialout user
C’est rien, mais faut s’en souvenir.
]]>Pour réduire la taille d’un PDF :
commande pour réduire la taille d’un PDF
gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=out.pdf file01.pdf file02.pdf
Je suis passé de 80Mo à 3Mo. C’est efficace. On ne perd pas en qualité d’image, par contre ce n’est plus du vectoriel.
]]>Pour faire fonctionner la carte wifi Broadcomm BCM43142 vendue avec des ordinateurs portables ASUS, il suffit d’installer un paquet qui va installer les bons modules tout seul :
téléchargement et compilation du module
sudo apt-get install bcmwl-kernel-source
Lors de votre prochain démarrage tout devrait bien se passer, et si vous ne souhaitez pas redémarrer :
chargement du module si on ne veut pas redémarrer
modprobe wl
À partir de là tout devrait bien fonctionner.
]]>Histoire de faire du lxc simplement, tout d’abord :
installation des programmes utiles
apt-get install bridge-utils lxc debootstrap
Puis on se crée un bridge dans notre eni :
bridge inscrit dans /etc/network/interface
auto lo
iface lo inet loopback
auto br0
iface br0 inet static
address 198.18.0.10 # là c'est ton ip locale
netmask 255.254.0.0 # ton netmask
network 198.18.0.0 # je vais pas faire ta conf non plus hein
gateway 198.18.0.1 # magie, ta gateway
bridge_ports eth0 # notre vraie interface, mappée à ce bridge
bridge_stp on
bridge_maxwait 0
bridge_fd 0
On peut finir par un ifup br0
ou un reboot
, ça dépendra de l’humeur de chacun.
Ensuite on a notre bridge qui tourne, on va configurer le réseau de nos machines LXC :
configuration réseau de notre première machine : “test”
cp /usr/share/doc/lxc/examples/lxc-veth.conf /etc/lxc/test.conf
vim /etc/lxc/test.conf # pour modifier les adresses IP
Maintenant on peut créer à proprement parler notre LXC :
création du lxc “test”
lxc-create -n test -f /etc/lxc/test.conf -t debian
Maintenant qu’on a créé notre vm on modifie vite-fait son fichier eni pour y enlever sa demande de DHCP au démarrage :
on vire le dhcp du démarrage
vim /var/lib/lxc/test/rootfs/etc/network/interfaces
Ce qui donne (oui, salade
est le vrai nom de ma machine) :
root@salade /var/lib/lxc # cat /var/lib/lxc/test/rootfs/etc/network/interfaces
auto lo
iface lo inet loopback
auto eth0
#iface eth0 inet dhcp
démarrage et extinction
lxc-start -n test
lxc-stop -n test
On reprend tout ce qu’on a dit dans la section de création du premier lxc, sauf qu’on change juste les IP dans le nouveau fichier de configuration de réseau avant de lancer la création de la machine.
Voilà, et avec tout ça je me retrouve avec 3 machines qui tournent avec tout juste un petit giga de disque. Pour en savoir un peu plus et éventuellement les créer direct dans des volumes LVM, suivre ce petit lien.
Des bisous et du datalove. ♥
Pour monter un petit proxy HTTP à la maison rapidement :
proxy SOCKS5 via ssh
ssh -D portlocal remotessh
ssh -D 12000 karchnu@chezmoi # exemple
SSH je t’aime.
Pour installer Mysql sur OpenBSD il faut faire :
installation
pkg_add -i -r mysql-server
Ensuite nous devons initialiser la base de donnée par défaut :
initialisation de la base de données
/usr/local/bin/mysql_install_db
De là on peut changer le mot de passe root :
changement du mot de passe root
/usr/local/bin/mysqladmin -u root password 'YOUR-Secret-Password'
Et enfin on peut démarrer l’application :
démarrage et extinction de mysql
/usr/local/bin/mysqld_safe --user=_mysql # démarrage
mysqladmin -u root -p shutdown # arrêt
Ok c’est sale, mais pour faire vite on peut vouloir laisser tomber la vérification d’un certificat quand on clone un dépôt.
erreur de vérification du certificat
server certificate verification failed.
CAfile: /etc/ssl/certs/ca-certificates.crt CRLfile: none
solution rapide et simple
export GIT_SSL_NO_VERIFY=1
ou
git config --global http.sslverify false
Alors je ne parlerai sans doute pas beaucoup de ruby
sur le blog, mais vu que c’est assez chiant à faire fonctionner je suis obligé de faire un post sur… comment bien installer ruby et toutes ses conneries de dépendances pour utiliser Octopress.
Ce sera très court, mais j’ai eu des erreurs différentes entre deux installations. Là j’ai encore souvenir de ce que je viens d’installer, donc autant en profiter pour faire un petit récap.
installation de ruby et ses dépendances pour octopress
ruby --version # doit être > 1.9.1 (2.X sur Ubuntu v14.10)
sudo gem install bundler
rbenv rehash
sudo apt-get install ruby-dev
bundle install
Et à partir de là j’ai droit… à me passer de l’autocomplétement qui aurait pu être sympa pour l’outil rake
; non là je dois préfixer cet outil par bundle exec
pour que tout fonctionne.
rake préfixé de bundle exec
bundle exec rake new_post['connerie de ruby']
Voilà. Oui je suis de mauvaise foi, sans doute que ruby c’est génial, mais fallait rendre ça plus simple. Là c’est juste pénible.
EDIT: pour retrouver le complètement automatique des commandes rake, il suffit de modifier le fichier “Gemfile”. Youhou /
gem 'rake', '~> 10.1.0'
Nous avons un système d’exploitation tout prêt, l’installation s’est bien déroulée mais il y a un petit problème : au démarrage le grub est complètement vide. On se retrouve avec uniquement un invité de commande, pas de menu.
Quand j’ai boot sur une clé pour réinstallé grub j’ai eu cette erreur :
erreur à l’installation de grub
Installing for i386-pc platform.
grub-install: warning: this GPT partition label contains no BIOS Boot Partition;
embedding won't be possible.
grub-install: error: embedding is not possible, but this is required for
cross-disk install.
Solution, on démarre sur une clé de secours, puis :
changement de flags du disque
parted /dev/sdb set 1 bios_grub on
Ensuite il faut qu’on monte notre nouveau système installé (la partition root avec un /boot complet) et on réinstalle grub :
{% codeblock %} mount /dev/sdb1 /mnt/ sudo grub-install –root-directory=/mnt /dev/sdb ```
Et je suis Charlie.
Récemment j’ai voulu refaire la manipulation que j’ai décrite dans un précédent article mais le logiciel hwinfo
n’est plus disponible pour ma distribution. Heureusement, un petit remplaçant (déjà dans mon système de base lui) qui est lshw
.
Ce que je souhaitais faire ici était de voir les périphériques audio pour les inverser et que ma sortie audio par défaut soit changée. J’ai donc exécuté lshw -C sound
et j’ai eu les identifiants des périphériques.
Suite de la procédure dans l’ancien article. ;)
J’ai présenté il y a peu iptables
, mais j’ai envie de passer aux systèmes BSD depuis quelques temps. Et sur ces systèmes, le pare-feu se fait via le programme pf
(Packet Filter). Rien à voir en terme de syntaxe, et c’est précisément ce qu’on va voir ici.
Cet article sera dédié à la création d’une passerelle utilisant pf
. Toute la configuration présentée ici est basique et ne prend pas en compte des techniques avancées (utilisation de tables, gestion de files d’attente, redondance réseau avec CARP
et pfsync
…).
Cet article ne sera pas mis à jour, cependant la page dédiée à pf sur le site fera l’objet d’une mise à jour régulière, suivant mon propre apprentissage de l’outil.
Le fichier pf.conf
est plutôt bien documenté (man pf.conf
, doc sur openbsd.org, livre The Book of PF
). Je vais reprendre ici quelques éléments présentés sur le site d’openbsd de façon succincte.
Toute la configuration du pare-feu se fait dans le fichier /etc/pf.conf
. Le programme pf
est actif au démarrage, mais on peut le désactiver en mettant PF=NO
dans le fichier /etc/rc.local
. Le contrôle du programme se fait via la commande pfctl
.
Les éléments manipulés dans ce fichier seront :
des macro
: adresse ou liste d’adresses ou plages IP, de ports, etcdes tables
: une structure qui gère des listes d’adressesdes options
: pour gérer comment fonctionne PFdes règles
: pour filtrer les paquets, les rediriger, faire du NAT…exemple de macro suivie d’une règle
int_if = "vio0"
pass on $int_if
Avec pass
une commande pour laisser passer le paquet, et on $int_if
ce qui arrive sur l’interface interne définie juste avant. Je n’explique pas plus, on verra par l’exemple.
On va commencer par configurer quelques macros
pour rendre le reste de la configuration le plus générique possible. N’oubliez pas que pour connaître les noms des interfaces disponibles on utilise ifconfig
sous BSD.
# dépend de votre matériel
ext_if = "tun0" # interface externe (branchée à la box)
int_if = "vio0" # interface interne (branchée au réseau local)
# plage d'IP interne liée à votre interface interne
# (RFC 1918, généralement dans 192.168.0.0/16)
localnet = $int_if:network
# ICMP autoriser les requêtes et les réponses unreach
icmp_types = "{ echoreq, unreach }"
pass inet proto icmp icmp-type $icmp_types
# tout ce qui sort sur l'interface externe (pour aller sur Internet)
# aura son adresse IP source remplacée par l'adresse IP de l'interface
# ext_if
# on met des parenthèses autour du nom de l'interface si son adresse IP
# peut changer, auquel cas pf se débrouille pour ne pas perdre les
# connexions déjà établies
match out on $ext_if from $localnet nat-to ($ext_if)
# par défaut, on bloque TOUT
block all
On a une passerelle entre la box de notre FAI et des clients (c’est-à-dire des ordinateurs sans serveur applicatif). On souhaite laisser la possibilité aux clients de sortir du réseau local. Bien entendu, on souhaite garder un certain contrôle sur ce qu’ils peuvent faire, si on a du windows à la maison, on a pas envie de devenir un nid à SPAM.
On va se contenter de donner le droit aux clients de se connecter au web (http et https), à des machines distantes (ssh), à leur compte email (pop3, imap, imaps) et quelques autres trucs. Avec pf
, nous n’avons pas besoin d’écrire les ports, nous pouvons faire référence à leur nom dans le fichier /etc/services
.
client_out = "{ ssh, domain, imap, imaps, pop3, auth, \
nntp, http, https, 6667 }"
# certains services utilisent aussi l'UDP
udp_services = "{ domain, ntp }"
# on laisse passer les paquets udp/tcp de façon inconditionnelle
pass quick inet proto { tcp, udp } to port $udp_services
# on laisse passer les connexions TCP autorisées
pass proto tcp to port $client_out
Pour l’instant, on a notre passerelle et des clients. On va ajouter un serveur web à notre infra.
On va vouloir que notre passerelle redirige les connexions entrantes sur les ports 80 et 443 vers le serveur web interne.
On laisse passer ce qui arrive sur l’interface externe, et on redirige via le mot clé rdr-to
vers l’adresse du serveur en interne. Il faudra laisser passer ensuite ce qui arrive sur l’interface interne vers le serveur web (aux ports associés).
webserver = "192.168.0.190"
webserverports = "{ http, https }"
# WEBSERVER
# redirection vers l'adresse IP local du serveur
pass in on $ext_if inet proto tcp to $ext_if port $webserverports rdr-to $webserver
# on laisse passer le trafic en direction du serveur (IP et port)
pass on $int_if inet proto tcp to $webserver port $webserverports
Cette configuration est suffisante pour un serveur web sans clients à l’intérieur du réseau local. Pour que les clients locaux puissent accéder au serveur web local, il faut détecter qu’on cherche à se connecter à l’IP de notre interface externe à partir d’une adresse locale. On redirige alors directement vers les ip des bons serveurs en local.
# connexion d'un client local à notre IP globale
# on le redirige vers le bon serveur en local
pass in on $int_if inet proto tcp from $localnet to $ext_if port $webserverports rdr-to $webserver
# NAT à l'IP interne pour ne pas que le serveur cherche à discuter
# directement au client local mais passe par la passerelle
pass out on $int_if proto tcp from $localnet to $webserver port $webserverports nat-to $int_if
Cette troisième partie est utile voire nécessaire dans ma situation. L’explication est simple : ma passerelle OpenBSD est actuellement une passerelle entre un tunnel VPN et mon réseau local. Ce n’est pas ma passerelle pour accéder à internet directement. Je souhaite que tout le trafic de mes serveurs passe par le VPN, qui a une adresse IP fixe et qui est neutre, le reste passe par mon opérateur directement.
Actuellement, lors d’une connexion, on redirige le trafic entrant vers le serveur web, sans changer l’adresse IP source, juste celle de destination (IP publique => IP locale du serveur web). Le serveur web peut alors répondre directement à l’émetteur de la requête, et sa passerelle par défaut est mon serveur BSD (avec pf). Il comprend qu’il faut faire du NAT en sortie
(changement de l’IP source de la réponse, celle du serveur web, par l’IP publique, de l’interface externe de la passerelle), tout se passe bien.
Le problème que j’ai actuellement est que sur un même ordinateur, je fais tourner un logiciel de partage en pair-à-pair, qui génère beaucoup de trafic, et un serveur de stockage de données Bacula (pour les sauvegardes). Je ne souhaite pas que mon trafic sur le VPN soit encombré, et donc je ne souhaite pas que le trafic du logiciel pair-à-pair sorte par le VPN.
La solution la plus simple à mettre en œuvre est de configurer la passerelle par défaut comme étant la box de l’opérateur, et de configurer pf pour qu’il fasse du NAT en interne. L’effet voulu est que la passerelle change l’adresse IP source des paquets entrants sur l’interface externe par l’adresse IP de son interface interne (comme fait précédemment pour les connexions « clients à serveur interne ») . Le logiciel serveur dans notre réseau local répondra alors à notre passerelle BSD.
serveur = "192.168.0.101"
serveurports = "{ 9103 }"
# comme pour l'autre serveur
pass in on $ext_if inet proto tcp to $ext_if port $serveurports rdr-to $serveur
pass out on $int_if inet proto tcp to $serveur port $serveurports
pass in on $int_if inet proto tcp from $localnet to $ext_if port $serveurports rdr-to $serveur
pass out on $int_if proto tcp from $localnet to $serveur port $serveurports nat-to $int_if
# faire du NAT à la réception sur tout ce qui arrive en direction du serveur
pass out on $int_if proto tcp to $serveur port $serveurports received-on $ext_if nat-to $int_if
pass out on $int_if proto tcp to $serveur port $serveurports received-on $int_if nat-to $int_if
pfctl -e
: activer pfpfctl -d
: désactiver pf
pfctl -f /etc/pf.conf
: charger le fichier pf.confpfctl -nf /etc/pf.conf
: vérifier que le fichier n’a pas d’erreur de syntaxe
pfctl -sr
: montrer les règles courantespfctl -ss
: montrer l’état des tablespfctl -si
: montrer les statistiques et compteurs de filtrespfctl -sa
: tout montrer
Les règles de pf
qui sont historisées (via la règle log
) peuvent être lues sur l’interface pflog0 via l’utilitaire tcpdump
. Cet outil comprend les règles de BPF ainsi que la possibilité de sélectionner une règle pf à afficher.
exemple de lecture de log
tcpdump -i pflog0 # lire tous les paquets des règles historisées
tcpdump -i pflog0 port domain # lire les paquets port 53 (résolution DNS)
Chaque règle qui est inscrite dans votre fichier pf.conf
est numérotée, ce qui a pour avantage de pouvoir être sélectionnée pour trier les logs.
log avec un numéro de règle pf
# règle historisée (mot clé : log)
pass log proto tcp to port $client_out
# chercher son numéro de règle
pfctl -vvs rules
# afficher les paquets qui correspondent à cette règle (X = numéro règle)
tcpdump -ttt -i pflog0 rulenum X
Les quelques options suivantes sont intéressantes à connaître pour le debug :
-ttt
: permet d’afficher les dates de façon compréhensible-n
: ne pas faire de reverse dns, afficher les ip pas les noms de domainerulenum
: pour spécifier un numéro de règle pf de votre pf.confPremier cas : on est à l’extérieur et on souhaite accéder à une machine (sur un port particulier) dans le réseau local de chez nous en passant par une machine à laquelle on peut accéder via ssh.
simple tunnel ssh
# portlocal : port sur notre ordinateur portable (à l'extérieur)
# machine : ordinateur dans le réseau local chez nous
# portmachine : port de ce même ordinateur
# remote-ssh : notre domaine
ssh -L portlocal:machine:portmachine remote-ssh
ssh -L 5000:192.168.0.1:80 chezmoi # exemple
Description rapide: on veut accéder à machine depuis un hôte distant (remote-ssh) qui servira de rebond. On s’y connecte et portlocal sera utilisé pour atteindre de façon transparente portmachine sur la machine distante. L’exemple donné est qu’on cherche à accéder à notre box depuis l’extérieur, en ayant un accès ssh à une machine de notre réseau local.
Ainsi, sur notre exemple, depuis notre machine à l’extérieur de notre réseau local on fait localhost:5000
dans notre navigateur on accède en réalité au port 80 de notre box chez nous.
Second cas : on est à l’extérieur et on souhaite qu’une machine dans notre réseau local puisse accéder à un port de notre machine à l’extérieur.
tunnel ssh inversé
# machine : ordinateur extérieur accédé depuis le réseau local chez nous
# portmachine : port de ce même ordinateur
# remote-ssh : notre domaine
# portdistant : port sur notre ordinateur du réseau local chez nous
ssh -TR portdistant:machine:portmachine remote-ssh
ssh -TR 1111:localhost:80 chezmoi # exemple
Le but de cette manœuvre est qu’une machine distante puisse accéder à un port en local en traversant le NAT. Il y a un port qui s’ouvre sur la machine distante, et tout ce qui passe dessus est redirigé vers un port en local.
Ici, la machine « chez moi » pourra accéder en local depuis son port 1111 à ma machine au port 80.
Les options :
-T
pour ne pas ouvrir de shell-R
pour faire un tunnel inverséOn est sur sa machine fixe, on veut accéder à une machine distante A, mais on n’a qu’une connexion à B dans son réseau local. On va donc utiliser la machine B pour accéder à A, mais on n’a pas de clé ssh pour accéder à A depuis B ! Oui, la vie est cruelle. Il faut donc utiliser B comme un simple rebond pour accéder à A.
Le rebond va simplement être utilisé pour ouvrir une socket réseau sur le port utilisé par SSH sur la machine à laquelle on cherche à accéder depuis notre machine rebond. On va écrire et lire dans cette socket comme si on accédait directement à la machine distante, de façon transparente de cette manière.
Configuration .ssh/config
sur ma machine locale :
Host B
Hostname B.example.com
User philippe
Port 2222
IdentityFile /home/%u/.ssh/id_dsa_b
Host A
Hostname A.example.com
User philippe
ProxyCommand ssh B "nc -q 0 %h %p"
tunnel ssh inversé
ssh A
Voici ce qui se passe :
Je suis sur mon ordinateur (utilisateur : philippe), dans mon .ssh/config
il y a les deux host A et B. Si je fais ssh B je vais sur B.example.com.
Si je fais ssh A je passe par ProxyCommand
qui se connecte à B puis lance netcat
(nc) qui lui se connecte à %h
qui est A
. On se retrouve sur A tout en étant passé par B.
C’est d’autant plus intéressant quand on souhaite accéder à des machines dans un sous-réseau distant en passant par une seule machine (avec le dns correctement configuré). Dans ce cas on peut utiliser des wildcards (étoiles) pour indiquer toutes les machines dans un domaine :
Host *.example.com
ProxyCommand ssh Rebond "nc -q 0 %h %p"
Et là on fait un simple ssh blah.example.com
et on y accède en passant par Rebond
.
Tous ces tricks sont pompés du blog de sebian.
LaTeX gère pour nous les espacements, mais parfois il faut pouvoir gérer à la main des espacements. Par exemple on veut que notre texte tienne en une page, alors on va diminuer l’espace entre les sections et les paragraphes. Pour ça, on a deux outils :
\vspace{-0.3cm}
\enlargethispage{1cm}
À adapter suivant les besoins. Rajouter 1cm à la page est assez limite, à utiliser qu’en cas de réelle nécessité (vspace
fait déjà bien le travail).
Je me demande souvent où j’ai mis tel ou tel fichier, je range bien mais la capacité de mes disques est limitée, donc j’en met un peu partout. Problème bien connu. Je pourrais utiliser LVM pour ça, pour avoir un seul volume logique qui contiendrait tous mes fichiers, mais ce n’est pas suffisant de retrouver mes données.
Il faut aussi qu’elles soient un minimum à l’abri d’une panne de disque. Pour ça, nous avons le RAID 5 qui est pas mal. Les données sont redondées, on a autant de disques durs qu’on veut, la capacité perdue n’est que d’un disque. Mais avoir une grande capacité, ce n’est pas suffisant, je ne veux pas qu’on puisse récupérer mes fichiers dans le cas d’un cambriolage (ou réquisition judiciaire, ’fin truc banal).
En plus de ça, il faut donc chiffrer les données.
J’ai donc choisi de prendre quelques disques, de les utiliser en RAID 5 , et je n’ai pas fait dans la demie-mesure : 4 × 2TB. Cela donne (4-1) * 2TB d’espace utilisable, c’est un bon début.
Pour le chiffrement, Luks car c’est un standard.
Attention, durant tout ce que je fais, je ne prétend aucunement être optimal. C’est la manière que j’ai utilisée pour faire mon infra, point.
Un petit mot sur ma configuration à la base. J’ai déjà deux disques 2TB chez moi, ils sont utilisés, il faut donc que je procède en plusieurs étapes.
Tout d’abord, on crée le RAID 5 avec les deux disques neufs en mode dégradé (le RAID 5 fonctionne normalement à partir de 3 disques) ; on indique 3 disques dont un manquant. Puis on chiffre le disque RAID avec le programme cryptsetup
.
Ensuite on déplace les fichiers des deux anciens disques vers le RAID, et on rajoute les deux disques dans le RAID. Une fois que c’est fait, on devrait avoir 3 disques actifs et un de spare (qui prendra la place d’un disque en cas de panne).
Problème, ça m’intéresse pas tellement d’avoir un disque de rechange, je veux surtout plus de place, donc on va indiquer au RAID qu’il faut utiliser le quatrième disque et « agrandir » le disque virtuel RAID. Cette étape n’est pas suffisante pour profiter de l’espace disque virtuel offert par le RAID, il faudra en plus redéfinir la taille du système de fichiers (ext4) via la commande resize2fs
.
En premier, on crée des partitions de même taille sur nos deux premiers disques, sinon ça va pas marcher. Ce qu’il faut vérifier c’est le bloc de début des partitions. Si vous avez des disques qui affichent « Sector size (logical/physical): 512 bytes / 4096 bytes », il faut que le bloc de début soit bien aligné avec la taille des secteurs. Pour faire ça automatiquement sans se prendre la tête, utilisez fdisk
.
partitionnement des disques
fdisk -c /dev/sdX
On arrive sur l’écran, on supprime toutes les anciennes partitions avec d
. Ensuite on en crée une nouvelle avec n
, qui commence au secteur 2048. On laisse tous les autres paramètres par défaut si on compte utiliser toute la taille du disque. Il faut penser à mettre une étiquette sur la partition pour indiquer qu’elle fera partie d’un RAID. Pour cela on utilise la commande t
sur la partition, et on y inscrit l’étiquette fd
. On finit par enregistrer nos modifications sur le disque avec w
.
Une fois qu’on a fait les deux partitions sur les disques, il faut vérifier qu’elles ont la même taille. Il suffit de retourner dans fdisk pour s’en convaincre.
Maintenant qu’on a créé nos deux partitions, on va en faire une grappe de RAID. Les plus geeks pourront s’amuser à changer des paramètres comme la taille des « chunks » pour mieux convenir à leurs besoins.
création de la grappe de RAID en mode dégradé
mdadm --create /dev/md0 --level=5 --raid-device=3 /dev/sda1 /dev/sdb1 missing
À partir de là nous pouvons chiffrer la partition virtuelle du RAID. Une fois que ce sera fait, il ne nous restera qu’à « ouvrir » cette nouvelle partition et y mettre un système de fichiers.
chiffrement de la partition RAID
cryptsetup luksFormat -c aes-xts-plain64 -s 512 -h sha256 /dev/md0
ouverture de la partition chiffrée
cryptsetup luksOpen /dev/md0 data
On se retrouve avec /dev/mapper/data
, et on va y écrire notre système de fichier (ext4). Il faut y intégrer une information à propos de notre RAID : la taille des « chunks » de notre RAID sera la taille des « stride » de notre système de fichiers. On retrouve la taille des chunks de notre RAID avec la commande mdadm --detail /dev/md0
. La taille de « stripe-width » correspond à la taille de notre RAID moins un, fois la taille d’un chunk. stripewidth = chunksize * (nb_disques - 1)
pour être plus clair.
J’utilise le paramètre -m 0
pour indiquer que je ne garde pas de place réservée à root. J’utilise mon RAID uniquement pour y mettre des données, donc autant ne pas gâcher de la place.
Note : si vous souhaitez partitionner ce nouveau disque virtuel, il serait intéressant d’utiliser LVM. Je ne le fais pas ici, je n’en ai pas l’utilité, tout sera enregistré directement sur une seule partition la plus grande possible.
écriture du système de fichiers
mkfs -t ext4 -m 0 -b 4096 -E stride=512,stripe-width=1536 /dev/mapper/data
On peut désormais (enfin !) monter notre partition et y écrire des choses, mount /dev/mapper/data /mnt
.
Pour l’instant nous avons un RAID 5 à deux disques en mode dégradé. Il faut ajouter les anciens disques dans la grappe RAID, donc on commence par déplacer les données des anciens disques vers le RAID. Une fois la copie faite, on reformate les anciens disques, on supprime des informations sur les anciens systèmes de fichiers utilisés (sinon mdadm ne va pas vouloir ajouter les disques) et on les ajoute dans le RAID.
nettoyage des meta-données des disques
wipefs -a /dev/sdX1
wipefs -a /dev/sdY1
Maintenant on les ajoute dans le RAID.
nettoyage des meta-données des disques
mdadm /dev/md0 --add /dev/sdX1
mdadm /dev/md0 --add /dev/sdY1
Un des disques est utilisé activement, l’autre est en spare. Il faut attendre que la synchronisation entre les trois disques actifs soit faite, pour ça : watch -d /proc/mdstat
.
Nous avons donc 4 TB de données (capacité de 2 disques) disponibles. Il faut maintenant activer le disque de spare, ce qui agrandira la partition virtuelle du RAID. Une fois que ce sera fait, il faudra agrandir notre système de fichiers.
Note : je démonte la partition chiffrée, mais je ne sais pas si c’est utile, simple précaution.
on démonte notre partition chiffrée
umount /mnt/
cryptsetup luksClose data
activation du dernier disque
mdadm /dev/md0 --grow --raid-devices 4
Comme tout à l’heure, on attend que le RAID ait fini de faire son travail via watch -d /proc/mdstat
, puis on force le test de notre système de fichiers avec e2fsck -f
(même s’il a l’air clean). Enfin, augmente la taille de notre système de fichiers.
déchiffrement de partition et agrandissement
cryptsetup luksOpen /dev/md0 data
e2fsck -f /dev/mapper/data
resize2fs -p -S 512 /dev/mapper/data
Et voilà. /
Maintenant qu’on a vu comment faire tout ça, les commandes à retenir pour le RAID et le chiffrement de partition sont :
assembler la grappe RAID et la fermer
mdadm --assemble --scan
mdadm /dev/md0 --stop
regarder ce qu’il se passe sur le raid
watch -d /proc/mdstat
ouvrir et fermer la partition chiffrée
cryptsetup luksOpen /dev/md0 nom-de-la-partition
cryptsetup luksClose nom-de-la-partition
Je souhaite faire une connexion sécurisée vers mon serveur de torrents. En effet, pas envie de voir quelqu’un qui sache ce que je fais sur ma connexion à la maison, ou que sur mon lieu de travail je lance des téléchargements de torrent comme video-de-mes-vacances.1080p.VO.multi.x264.mkv
.
Pour ça, il faut forcer la connexion SSL à notre site, qui sera un proxy vers le serveur de torrents qui écoute en local. Peu importe le client torrent, j’utilise actuellement le démon deluged
couplé à deluge-web
, mais transmission
marche bien aussi. À partir d’ici on suppose que l’URL du site à sécuriser est « torrent.example.com ».
Donc pour ça, on va commencer par créer un fichier contenant les mots de passe des utilisateurs que l’on souhaite laisser passer :
fichier de mot de passe des utilisateurs
htpasswd -c /path/to/passwords/passwdfile USER
Pour la suite, tout se fait dans un fichier d’hôte virtuel (nom arbitraire) comme /etc/apache2/sites-available/torrent.example.com-ssl
. On force la connexion SSL au site torrent.example.com
:
<VirtualHost *:80>
ServerName torrent.example.com
Redirect permanent / https://torrent.example.com/
</VirtualHost>
<IfModule mod_ssl.c>
<VirtualHost *:443>
SSLEngine On
SSLCertificateFile /path/to/ssl/ca.cert
SSLCertificateKeyFile /path/to/ssl/ca.key
ServerAdmin moi@example.com
ServerName torrent.example.com
ProxyPass / http://IPLOCALE:PORT/
ProxyPassReverse / http://IPLOCALE:PORT/
<Proxy *>
AuthType Basic
AuthName intranet
AuthUserFile /path/to/passwords/passwdfile
Require user USER # ne laisse passer QUE USER
# Require user USER1 USER2 USER3
</Proxy>
ErrorLog ${APACHE_LOG_DIR}/torrent.example.com-ssl.err
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/torrent.example.com-ssl.log combined
</VirtualHost>
</IfModule>
Je ne réexplique pas la génération des certificats auto-signés, expliquée dans un précédent billet. À partir d’ici, a2ensite torrent.example.com-ssl
puis service apache2 reload
devraient suffire pour ne laisser passer qu’un seul utilisateur, et redirige la connexion SSL vers une adresse IP locale, sur un certain port, où écoute votre serveur de torrents. Si on rajoute à cela l’authentification supplémentaire de votre client bittorrent, il va être difficile de faire mieux au niveau de la sécurité.
J’ai réussi à faire ça en lisant la documentation suivante :
Voici les manipulations réalisées pour configurer l’imprimante Epson XP-312 sur un ordi tournant sous Ubuntu 14.04 :
Premier démarrage (seulement si vous venez d’acquérir l’imprimante)
À ce stade, vous pouvez déjà faire des photocopies. Passons à la configuration pour les impressions :
Imprimer
# dpkg -i epson-inkjet-printer-escpr_1.4.0-1lsb3.2_amd64.deb
Félicitations, vous pouvez désormais imprimer ! Passons à la marche à suivre pour le scanner :
Scanner
# dpkg -i iscan-data_1.29.0-2_all.deb
# dpkg -i iscan_2.29.3-1\~usb0.1.ltdl7_amd64.deb
C’est fini, vous pouvez désormais numériser vos documents avec votre logiciel habituel (Simple Scan fonctionne très bien) ! :)
Remarque
Pour rappel, vous pouvez définir votre Epson XP-312 comme étant votre imprimante « par défaut ». Pour cela, rendez-vous sur l’interface de Cups, puis choisissez Admininistration -> gérer les imprimantes. Cliquez sur l’imprimante choisie, puis dans le menu déroulant « Administration », sélectionnez « définir par défaut ».
Notre objectif est d’avoir plusieurs sites web avec du SSL sur une seule machine, avec un serveur apache2, et qui ne possède qu’une seule adresse IP publique. Ceci est un cas typique dans un cas d’autohébergement (comme chez moi). Le problème c’est que pour SSL, il faut sélectionner la bonne paire de clés du côté du serveur et ensuite on peut envoyer des données, comme par exemple, le nom de domaine sur lequel on veut se connecter. Problème, pour sélectionner la bonne paire de clés il faut connaître le nom de domaine sur lequel on souhaite se connecter.
La solution à ça c’est le SNI qui est une extension de TLS qui permet d’envoyer le nom de domaine sur lequel vous souhaitez vous connecter avant d’entâmer la connexion SSL.
Il n’y a rien à faire pour l’activer concrêtement, par contre il faut activer le SSL avec la bonne configuration des hôtes virtuels, donc on va voir ça ici (c’est simple, mais pas intuitif).
on créé un répertoire dédié
mkdir -p /etc/apache2/ssl/
Il faut copier son /etc/ssl/openssl.cnf
dans le répertoire puis on le modifie pour y modifier ou ajouter les quelques valeurs suivantes (elles sont toutes plus ou moins au même endroit) :
default_bits = 4096
countryName_default = FR
stateOrProvinceName_default = Alsace
localityName_default = Strasbourg
organizationName_default = ""
commonName_default = fqdn.de.votre.machine
emailAddress_default = votre.adresse@mail
On crée un fichier d’extension pour ajouter des noms de domaines qui seront gérés par votre certificat, comme par exemple:
[ monutilisateur ]
subjectAltName = DNS:example.com, DNS:www.example.com, DNS:blog.example.com
création d’une clé autosignée
openssl req -nodes -newkey rsa:4096 -new -out ca.csr -config openssl.cnf
openssl rsa -in privkey.pem -out ca.key
openssl x509 -req -days 365 -in ca.csr -signkey ca.key \
-out ca.cert -extfile monutilisateur.ext \
-extensions monutilisateur
chmod 400 ca.key ca.cert
Tout d’abord, il faut prendre en compte la configuration des hôtes virtuels, donc on va modifier le fichier /etc/apache2/ports.conf
et lui indiquer qu’on va regarder les hôtes virtuels en ssl, avec une configuration basique on devrait avoir :
NameVirtualHost *:80
Listen 80
<IfModule mod_ssl.c>
NameVirtualHost *:443 # sites configurés avec SSL
Listen 443
</IfModule>
<IfModule mod_gnutls.c>
NameVirtualHost *:443 # sites configurés avec SSL
Listen 443
</IfModule>
On va créer le fichier /etc/apache2/sites-available/blog.example.com-ssl
puis l’activer :
SSLEngine On
SSLCertificateFile /etc/apache2/ssl/ca.cert
SSLCertificateKeyFile /etc/apache2/ssl/ca.key
ServerAdmin me@example.com
ServerName blog.example.com
ServerAlias www.example.com
DocumentRoot /path/to/website/
<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>
<Directory /path/to/website/>
Options FollowSymLinks Indexes
AllowOverride None
Order allow,deny
allow from all
</Directory>
ErrorLog ${APACHE_LOG_DIR}/blog.example.com-ssl.err
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/blog.example.com-ssl.log combined
<FilesMatch "\.(cgi|shtml|phtml|php)$">
SSLOptions +StdEnvVars
</FilesMatch>
<Directory /usr/lib/cgi-bin>
SSLOptions +StdEnvVars
</Directory>
</VirtualHost>
</IfModule>
on active le module ssl puis le nouveau site dans apache
a2enmod ssl
a2ensite blog.example.com-ssl
service apache2 reload
Par la suite, chaque nouveau site devra être configuré de la même manière ; un nouveau fichier dans /etc/apache2/sites-available/
comme on l’a vu tout à l’heure, puis a2ensite fichier
et service apache2 reload
.
Si j’ai oublié quelque-chose, envoyez-moi un e-mail.
]]>Si on veut savoir comment est fait Internet, rien de mieux que d’expérimenter soi-même. Pour ça, on a des initiatives comme DN42.
C’est un réseau de réseaux (comme Internet), dont chaque personne connectée a son préfixe et son propre numéro d’AS.
Je vais faire une petite traduction de la partie « about » de leur wiki, qui est relativement clair.
{% blockquote Wiki de DN42, à propos %} DN42 est un réseau de VPN dynamique, qui emploie des technologies utilisées sur Internet (BGP, base de données « whois », DNS, etc). Les participants se connectent entre eux en utilisant des tunnels (GRE, OpenVPN, Tinc, IPsec) et échangent des routes via BGP. Il y a un certain nombre de services qui sont fournis sur le réseau et DN42 s’inter-connecte avec d’autres réseaux comme ChaosVPN ou Freifunk. {% endblockquote %}
S’il vous a fallu mes explications (voire plus) pour comprendre, c’est sans doute que la suite de l’article n’est pas vraiment faite pour vous. Si cependant vous êtes assez curieux pour continuer, vous pourrez sans doute apprendre pas mal de choses sur les réseaux informatiques en général. Bon courage dans tous les cas ! /
Cela permet de reproduire ce qu’il se passe sur internet :
Pour ça, il y a un bon paquet de personnes qui sont là pour aider, pour documenter, et même pour fournir des services. Le but est d’apprendre en manipulant, et un effet de bord plutôt sympathique est qu’on créé un réseau alternatif « par dessus » Internet (on appelle ce principe, un réseau « overlay », une surcouche).
On retrouve tout ce qui peut être sur Internet, mais accessible que par des personnes connectées à DN42. Exemple : des sites web, un système DNS interne (et parallèle au système DNS sur Internet), du partage de fichiers… Internet en miniature, entre potes.
Attention, il ne faut pas croire que DN42 est le réseau overlay qui va vous permettre d’échanger des choses illégales en toute quiétude. DN42 est une base d’échange de connaissances et un environnement intéressant pour manipuler du réseau. Se connecter à DN42 revient à accéder aux réseaux présents sur celui-ci, en aucun cas il ne permet d’accéder ensuite anonymement à Internet, en prenant l’adresse IP d’un autre utilisateur de DN42 pour se connecter à Internet par exemple.
Il y a un HackerSpace cool près de chez nous, on a envie de partager des fichiers mais qu’entre potes, monter un réseau d’anarchistes libertaires. Pas de risque de censure, pas de risque pour votre vie privée, seuls les gens de confiance y accèdent. Ce serait une application intéressante d’un réseau comme DN42.
Pour ça, c’est très simple, il y a une page qui explique bien tout : Getting Started.
Et pour les gens qui veulent un point d’entrée, je conseille les gens de la fédération FDN qui ont une page de wiki bien faite et avec des bouts de configuration intéressant. Ils s’inter-connectent via Tinc (connexion VPN entre les nœuds) et sont sympas, venez ! :)
DN42 est un réseau communautaire. Une fois les connaissances acquises en réseaux informatiques grâce à un projet comme celui-ci, n’importe qui pourra recréer un réseau communautaire « type DN42 » et y faire ce qu’il souhaite. Par exemple, si on reprend le schéma de tout à l’heure, on peut dire que les gens sur le réseau acceptent qu’on sorte du réseau communautaire à partir d’une connexion VPN vers un pays sympa, comme la Suède, qui ne stocke aucun historique de connexion. Ce que cela donnerait, c’est un ensemble de personnes connectées à notre réseau, et qui peuvent partir se connecter sur Internet de façon suffisamment anonyme pour ne pas trop se soucier des vilains méchants opérateurs qui font du DPI.
Pour voir quelques explications supplémentaires, voir une vidéo MindFuck NetBSD (Pas Sage En Seine 2012) où on présente une topologie à peu près similaire à celle que j’ai montrée ici. Le but du présentateur est de préserver sa vie privée en empêchant un vilain FAI de voir ce qu’il fait sur Internet. Pour cela, il doit sortir sur Internet via des connexions VPN vers d’autres pays. Une connexion VPN vers un autre pays est un service assez fréquent que l’on peut voir sur certains sites, pas de soucis. Pour que globalement ça marche bien un peu tout le temps, c’est mieux de faire ça avec de la redondance. La redondance est apportée par ses potes avec qui il est connecté, qui se partagent des adresses dans des plages d’adresses privées (annoncées via BGP entre eux). En cas de soucis avec un lien VPN, on route la sortie vers Internet par le réseau du copain d’à côté, qui a souscrit à un autre service VPN. Chaque copain est un point de sortie.
Si on rajoute les connexions VPN vers l’étranger, cela donnerait quelque chose comme :
DN42 est une première approche des réseaux, ça peut être fun. Il y a un suffisamment d’information sur les sites de dn42 et de la ffdn pour démarrer, et s’il y a des problèmes pour s’y mettre il y a les canaux IRC. /
]]>Voici mon premier post, pour parler du fait que je passe de wordpress à octopress. N’utilisant absolument pas les fonctionnalités de wordpress, et ayant envie de voir d’autres horizons, voici mon nouveau blog.
La gestion par dépôt git de mon blog me semble une évidence, tout comme pour mon wiki. Cela ne sert à rien d’avoir un interpréteur lourd pour au final ne pas faire du web 2.0 avec des commentaires et tout et tout, alors c’est parti pour le grand nettoyage: je vire wordpress.
Première impression d’Octopress : c’est convenable. L’installation est assez simple, bien expliquée sur le site, faire un nouveau post revient à créer un simple fichier texte dans un répertoire avec un certain format (généré automatiquement avec la commande « rake »). Petit bémol cependant, pour rajouter une page sur la barre de navigation il faut aller éditer le petit bout de fichier qu’il faut à la main… hey les gars, on a une commande pour créer une page, pourquoi ne pas l’inclure par défaut directement ?
{% blockquote Barack Obama, retour de vacances %} Salut ça va ? {% endblockquote %}
Un petit post pour aider ceux qui auraient le même problème que moi.
En passant Xubuntu sur mon netbook de la version 13.04 à 13.10, le système jusqu’à alors en français a basculé dans la langue de Shakespeare. La “prise en charge des langues” en graphique ne me permettait plus de sélectionner le français (qui restait grisé).
Pour solutionner le problème, je me suis tout d’abord assurée que je possédais bien les locales en français à l’aide de la commande suivante :
locale-gen
J’ai ensuite édité les 2 fichiers suivants (après en avoir fait une sauvegarde par sécurité)…
/etc/default/locale
~/.pam_environment
…en remplaçant l’anglais par le français. (ex : LANG=“fr_FR.UTF-8” au lieu de LANG=“en_US.UTF-8”)
Après un redémarrage, le système est de nouveau francophone ! :D
]]>J’ai fait un topo sur les différents algorithmes d’évitement de congestion pour mon master, je mets le résultat en ligne. Je l’utiliserai pour agrémenter wikipedia. :)
Le lien du PDF. Je mettrai sans doute les sources en ligne un jour, n’hésitez pas à demander ou faire des suggestions (par email).
Pour copier du texte dans vim ou depuis vim en dehors, il suffit de copier dans le registre “+”.
On sélectionne le bout de texte qu’on souhaite copier, puis "+y
(se traduit par: « registre + copier »). Si on veut copier du système vers vim, même chose en remplaçant « y » par « p » (paste). Aussi, si on veut copier simplement d’une instance de vim à une autre, on peut utiliser le registre « * ».
Si on veut copier tout le fichier dans lequel nous sommes, on peut faire 1G"+yG
, plutôt simple (se traduit par « déplacement ligne 1, registre + copier jusqu’à la fin du fichier »).
IT’Z DAT SOLUZIONNE (anglais avec un accent allemand) !
Vous l’avez remarqué, et ça vous énerve : LaTeX se donne le droit de changer l’emplacement des images que vous mettez dans votre code pour qu’elles soient « mieux placées ». Si, comme moi, vous ne placez pas au hasard les images que vous mettez dans vos rapports et que ça casse un peu les joyeuses de voir après la compilation que nos jolis graphes ne se trouvent pas dans les bonnes parties, voici la solution :
\usepackage{float}
Puis, lorsqu’on ajoute une image, on précise l’option “H” :
\begin{figure}[H]
Bien sûr, il y a plein d’autres options.
]]>C’est simple, pourtant j’ai bêtement perdu du temps sur ça.
convert -flip -rotate 180 image.png miroir.png
Un post assez court sur « comment installer un webmail chez soi même si on n’est pas doué ».
Avoir un serveur email chez soi (ou à soi plutôt) c’est important. Cela a des avantages non négligeables, et notamment cela permet d’être indépendant de tout service « gratuit où c’est nous la marchandise », les emails vous appartiennent et il n’y a que VOUS qui les voyez (oui, Google, Yahoo,… peuvent regarder vos emails). Plus ça va et plus les agences gouvernementales viennent fouiller dans nos vies privées, beaucoup d’articles sur le net en parlent, pas besoin de ressortir un pavé à ce sujet. De ce fait, il devient de plus en plus important et intéressant pour tout un chacun de devenir maître de sa vie numérique.
Bien sûr cela n’est pas à la portée de tous sans un bon tutoriel, ne traitant pas que de l’installation d’un logiciel en particulier mais ayant une vision plus large. Ceci est une difficulté lorsque l’on débute : savoir par où commencer.
J’héberge mon service email depuis un petit moment maintenant, et ça marche bien (voir mon article sur Postfix). Cependant ce n’est pas adapté à tout le monde, et avoir une interface web accessible de n’importe-où est intéressant. Pour ma part, j’ai voulu fournir un webmail à mes parents, pour qu’ils puissent enfin profiter d’une gestion d’emails propre. Ce que j’appelle « webmail » est une interface permettant de gérer ses emails depuis un simple navigateur web comme firefox (comme gmail par exemple).
Pourquoi Roundcube ? Au départ, j’ai voulu installer SOGO (un autre webmail). J’ai lu la documentation et elle m’a paru bien longue (un PDF), le soft m’a l’air très adapté à de grandes boîtes mais pour le pékin moyen que je suis j’ai surtout trouvé que devoir posséder un serveur LDAP en plus d’un SGBD et d’un serveur web pour faire tourner le bousin c’était un peu lourd pour 3 personnes. On m’avait conseillé SOGO pour sa gestion de calendrier, super mais j’en utilise pas et je n’en éprouve pour l’instant pas le besoin alors je vais voir ce qui se fait d’autre. Juste après j’ai lu la pauvre demie page d’installation de Roundcube qui te dit qu’une fois la copie du dossier effectuée l’installation est déjà presque finie. Haha, Sogo je te verrai plus tard.
Au final, voici les pré-requis pour faire tourner notre serveur de messagerie avec une interface web toute jolie :
Petite note sur le fonctionnement de l’installation que je vais décrire : postfix reçoit et émet les emails. Il donne les emails reçus à procmail qui va les stocker en format maildir dans le répertoire personnel de l’utilisateur. Dovecot ne sert qu’à fournir ce dossier au webmail en IMAP+SSL. Postfix, procmail et dovecot se trouvent sur la même machine, le serveur web peut être où vous le souhaitez.
Pour rendre l’explication encore plus simple :
~/Maildir/cur
) ;~/Maildir
.Avant toute chose il faut gérer son nom de domaine. Pour cela, il faut faire un enregistrement de type « MX » dans votre zone. Si cela ne vous parle pas des masses, c’est un peu normal. En gros : quand on veut savoir qui est derrière « example.com » pour accéder à une page web (par exemple), on va demander à notre serveur DNS qui est « example.com ». Pour cela, on demande quel est l’enregistrement A (A = adresse) de ce nom de domaine. Pour envoyer des emails c’est pareil, sauf que c’est un enregistrement de type MX (mail exchange). Je ne vais pas rentrer dans des explications trop fournies sur le système de DNS, sachez simplement qu’une personne possédant un nom de domaine doit entrer quelques informations dans ce qu’on appelle sa « zone DNS » pour qu’on sache qui se cache derrière son nom de domaine.
Voici ce qu’il faut mettre dans votre zone : mail IN A 211.197.196.185 mail IN AAAA fc00::100:c688:ce47:c817:e2ac::1 example.com. IN MX 10 mail.example.com. En mode capitaine évidence : il faut changer les adresses IP, le nom de domaine ainsi que le nom d’hôte du serveur email pour l’adapter à votre cas.
L’installation de tout ça est assez simple : # postfix, pour la configuration : http://blog.karchnu.fr/?p=805 apt-get install postfix
# dovecot
apt-get install dovecot-core dovecot-mysql dovecot-imapd
# web
apt-get install apache2 php5 php5-mysql
# roundcube : allez sur http://roundcube.net/download pour télécharger l'archive puis :
tar xf roundcube*.tar.gz
rm roundcube*.gz
mkdir -p /srv/www/
mv roundcubemail* /srv/www/roundcube/
chown -R www-data /srv/www/roundcube/
</code></pre>
On vient donc de mettre les fichiers de roundcube où il fallait, on lui a donné les bons droits pour qu'apache puisse y accéder, maintenant il va falloir configurer Postfix (http://blog.karchnu.fr/?p=805), dovecot et apache. Pour dovecot, le fichier <code>/etc/dovecot.conf</code> :
<pre><code>
# Général
listen = *,[::]
mail_privileged_group = mail
log_timestamp = "%Y-%m-%d %H:%M:%S "
auth_mechanisms = plain login
service auth {
user = root
}
userdb {
driver = passwd
}
# on utilise simplement le mot de passe de l'utilisateur local
passdb {
driver = pam
}
protocols = imap
# Sécurité
ssl = required
# bien sûr, il faudra remplacer ça par votre certificat SSL
ssl_cert = </etc/postfix/tls/mail.example.com.cert
ssl_key = </etc/postfix/tls/mail.example.com.key
ssl_protocols = "!SSLv2"
ssl_cipher_list = !aNULL:!eNULL:!EXPORT:!MD5:!DES:!LOW:kEDH:HIGH:MEDIUM
disable_plaintext_auth=yes
Le fichier /etc/apache2/sites-available/000-default.conf sur la machine hébergeant roundcube :
<VirtualHost *:80>
ServerAdmin exemple@example.com
ServerName mail.example.com
# optionnel, si vous avez plusieurs noms pour cette machine
ServerAlias webmail.example.com
# c'est dans ce répertoire qu'il faut mettre les fichiers de roundcube
DocumentRoot /srv/www/roundcube/
<Directory "/srv/www/roundcube">
Options FollowSymLinks Indexes Includes
AllowOverride All
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/mail.example.com.err
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/mail.example.com.log combined
</VirtualHost>
Une fois que vous avez mis ces fichiers où il fallait :
service dovecot restart
service apache2 restart
Pour finir l’installation, il faut se rendre sur votre nom de domaine configuré dans apache, dans le répertoire /installer (ici cela donnerait http://mail.example.com/installer) pour finir l’installation de Roundcube. Il vous demandera de remplir quelques informations assez simples, puis vous devrez télécharger un fichier qu’il aura généré (le fichier main.inc.php
) et le mettre dans /srv/www/roundcube/config
Dans un autre article je gèrerai la livraison en local avec un filtrage (supprimer les spams, rediriger des emails dans un dossier en particulier…), et ce sera fait avec Sieve + dovecot, qui remplacera procmail. Comme d’habitude, les commentaires sont fermés, n’oubliez pas que si vous souhaitez me parler vous pouvez aller sur irc : #arn sur irc.geeknode.net ou utiliser mon adresse email karchnu CHEZ karchnu POINT fr.
Après un passage de Xubuntu 12.04 à 12.10, l’imprimante Canon MP600 ne fonctionnait plus.
Le message suivant était visible sur l’interface web de cups : “The PPD version (5.2.8-pre1) is not compatible with Gutenprint 5.2.9.”
Pour que l’imprimante fonctionne à nouveau, j’ai simplement tapé ces 2 commandes dans un terminal :
sudo cups-genppdupdate
sudo service cups restart
Et voilà, tout semble fonctionner à nouveau :)
Si cela peut être utile à quelqu’un, voici les manipulations que j’ai réalisées pour configurer un hôte virtuel avec Apache2, ici en autorisant la réécriture d’URL (fonctionne sur Debian et dérivées) :
Par exemple, si le projet se trouve dans /home/toto/monprojet :
Dans /etc/hosts → 127.0.0.1 doit correspondre aussi à monprojet
Dans /etc/apache2/sites-available → rajouter un fichier monprojet
Voici son contenu : (on peut éventuellement choisir un fichier spécifique pour les logs d’erreur de son site)
<VirtualHost *:80>
ServerAdmin webmaster@localhost
ServerName monprojet
DocumentRoot /home/toto/monprojet/public/
Options Indexes FollowSymLinks
AllowOverride All
Order allow,deny
allow from all
ErrorLog ${APACHE_LOG_DIR}/error.log
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
a2ensite monprojet
a2enmod rewrite
service apache2 restart
Note : En cas de problème, penser à vérifier les droits + regarder les logs d’erreurs dans : /var/log/apache2/
Et non, je ne vais parler ici de Live USB…
Juste un petit post pour vous faire part d’un test que j’ai fait récemment : l’installation de Linux (Debian dans ce cas précis) sur une clé USB. Cela permet d’avoir une distribution “nomade”, utilisable partout. Et, contrairement à un live USB, tout ce qui fait dessus est conservé ! Bien pratique :)
Pour avoir ma distrib sur clé, j’ai eu recours à 2 clés USB : la première qui contenait l’image de Debian (comme pour une installation classique), et la seconde pour accueillir la distribution “portative”.
Ensuite, il suffit de brancher les 2 clés à l’ordinateur et de procéder comme pour une installation standard, à ceci près qu’il faudra sélectionner la clé et non le disque dur comme emplacement pour l’installation. Un point important : concernant le chargeur de démarrage, il devra impérativement être installé sur la clé et non sur le disque !
Dans mon cas, l’installation s’est déroulée sans problème mais a été longue, car j’ai choisi de chiffrer la clé (vu qu’une clé peut facilement être égarée, je le recommande, on n’est jamais trop prudent).
Au final : le tout fonctionne et n’est pas trop lent. Mon seul doute concerne la durée de vie de la clé, qui s’en trouvera probablement réduite…
Afin de mettre à jour régulièrement les différentes informations que je glanne sur le net à propos des serveurs mails, j’ai fait une page qui récapitule ce que je sais.
Bon, un tuto à peine plus conséquent que d’habitude : comment configurer son smtpd (postfix ici) facilement & rapidement, en ayant directement les quelques bonnes options qui permettent que ça tombe un peu magiquement en marche.
Tout d’abord : il faut se créer un certificat (on va l’auto-signer, il n’y aura qu’une seule étape à changer si on veut le faire signer par une autorité comme CACert).
Après avoir installé openssl, on génère une clé :
génération d’une clé RSA
openssl genpkey -algorithm RSA -out example.com.key -pkeyopt rsa_keygen_bits:4096
On génère le « Certificate Signing Request » qui nous servira à créer notre certificat auto-signé ou le certificat signé par une entité quelconque (non vu ici) :
requête de signature de certificat
openssl req -new -key example.com.key -out example.com.csr
Dernière étape, on génère le certificat final :
certificat final
openssl x509 -req -days 365 -in example.com.csr -signkey example.com.key -out example.com.cert
J’ai mis ces fichiers dans /etc/postfix/tls/, faites comme bon vous semble. Ensuite il faut générer une clé Diffie Hellman, qui permet de négocier une connexion (échange de clés).
certificat final
openssl genpkey -genparam -outform PEM -algorithm DH -out dh_1024.pem -pkeyopt dh_paramgen_prime_len:2048
On revient à la configuration de Postfix, et pour pas faire une longue liste d’explications inutiles, je préfère directement poster la configuration de mon vrai serveur @home.
root@frite /etc/postfix # cat main.cf
# http://www.postfix.org/postconf.5.html#smtpd_banner
# un petit texte affiché en début de connexion ($mail_name vaut par défaut Postfix, $mail_version je vous laisse deviner)
smtpd_banner = $myhostname ESMTP $mail_name ($mail_version)
# http://www.postfix.org/postconf.5.html#biff
# pour avertir les utilisateurs quand on reçoit un nouvel e-mail, faut pas l'activer si on a beaucoup d'utilisateurs
biff = no
# http://www.postfix.org/postconf.5.html#append_dot_mydomain
append_dot_mydomain = no
# http://www.postfix.org/postconf.5.html#delay_warning_time
# après ce délai, l'émetteur reçoit une copie de l'entête des messages qui sont toujours en attente d'être traités
delay_warning_time = 4h
# http://www.postfix.org/postconf.5.html#disable_vrfy_command
disable_vrfy_command = yes
# http://www.postfix.org/postconf.5.html#mydomain
# mon domaine
mydomain = karchnu.fr
# http://www.postfix.org/postconf.5.html#myhostname
# le fqdn de mon serveur de mails
myhostname = mail.karchnu.fr
# http://www.postfix.org/postconf.5.html#masquerade_domains
# sert à modifier les entêtes des mails à l'envoi, exemple :
# masquerade_domains = foo.example.com example.com
# change "user@any.thing.foo.example.com" en "user@foo.example.com", mais change "user@any.thing.else.example.com" en "user@example.com".
masquerade_domains = $mydomain
# http://www.postfix.org/postconf.5.html#home_mailbox
# le format de boîte que j'utilise (Maildir et non mbox)
home_mailbox = Maildir/
# http://www.postfix.org/postconf.5.html#alias_maps
alias_maps = hash:/etc/postfix/aliases
# http://www.postfix.org/postconf.5.html#alias_database
alias_database = hash:/etc/postfix/aliases
# http://www.postfix.org/postconf.5.html#myorigin
# c'est à partir de cette adresse qu'est envoyé le courier et c'est pour cette adresse qu'on reçoit le courier
myorigin = karchnu.fr
mydestination = mail.$mydomain, $mydomain, localhost
# http://www.postfix.org/postconf.5.html#mailbox_size_limit
mailbox_size_limit = 1073741824
# http://www.postfix.org/postconf.5.html#message_size_limit
message_size_limit = 15728640
# http://www.postfix.org/postconf.5.html#recipient_delimiter
recipient_delimiter = +
# http://www.postfix.org/postconf.5.html#smtpd_sasl_auth_enable
smtpd_sasl_auth_enable = yes
# http://www.postfix.org/postconf.5.html#smtpd_sasl_security_options
smtpd_sasl_security_options = noanonymous
# http://www.postfix.org/postconf.5.html#smtpd_sasl_local_domain
smtpd_sasl_local_domain = $mydomain
# http://www.postfix.org/postconf.5.html#broken_sasl_auth_clients
broken_sasl_auth_clients = no
# http://www.postfix.org/postconf.5.html#smtpd_sender_login_maps
smtpd_sender_login_maps = hash:/etc/postfix/sender_login
# http://www.postfix.org/postconf.5.html#smtpd_sender_restrictions
smtpd_sender_restrictions =
reject_unknown_sender_domain,
reject_non_fqdn_sender,
reject_authenticated_sender_login_mismatch
# http://www.postfix.org/postconf.5.html#smtpd_recipient_restrictions
smtpd_recipient_restrictions =
permit_sasl_authenticated,
reject_unknown_recipient_domain,
reject_non_fqdn_recipient,
reject_unauth_destination
# http://www.postfix.org/postconf.5.html#mailbox_command
# permet de récupérer les e-mails et de les placer où on le souhaite
# par l'intermédiaire d'un programme externe
mailbox_command = /usr/bin/procmail -f- -a $USER
# http://www.postfix.org/postconf.5.html#smtpd_helo_required
smtpd_helo_required = yes
# *********************************************
# * TLS *
# *********************************************
# http://www.postfix.org/postconf.5.html#smtp_use_tls
smtp_use_tls = yes
# http://www.postfix.org/postconf.5.html#smtpd_use_tls
smtpd_use_tls = yes
# http://www.postfix.org/postconf.5.html#smtp_tls_security_level
smtp_tls_security_level = may
# http://www.postfix.org/postconf.5.html#tls_export_cipherlist
# pour interdire les chiffrements de merde
tls_export_cipherlist = !aNULL:!eNULL:!EXPORT:!MD5:!DES:!LOW:kEDH:HIGH:!MEDIUM
smtpd_tls_mandatory_protocols=!SSLv2,!SSLv3
smtp_tls_mandatory_protocols=!SSLv2,!SSLv3
smtpd_tls_protocols=!SSLv2,!SSLv3
smtp_tls_protocols=!SSLv2,!SSLv3
# http://www.postfix.org/postconf.5.html#smtpd_tls_auth_only
# http://www.postfix.org/postconf.5.html#smtpd_tls_security_level
# forcer l'utilisation de TLS avant d'envoyer l'identification
smtpd_tls_auth_only = yes
smtpd_tls_security_level = may
# http://www.postfix.org/postconf.5.html#smtpd_tls_auth_only
# http://www.postfix.org/postconf.5.html#smtpd_tls_key_file
# http://www.postfix.org/postconf.5.html#smtpd_tls_cert_file
# http://www.postfix.org/postconf.5.html#smtpd_tls_loglevel
# http://www.postfix.org/postconf.5.html#smtpd_tls_received_header
smtpd_tls_auth_only = yes
smtpd_tls_key_file = /etc/postfix/tls/mail.karchnu.fr.key
smtpd_tls_cert_file = /etc/postfix/tls/mail.karchnu.fr.cert
smtpd_tls_loglevel = 1
smtpd_tls_received_header = yes
# http://www.postfix.org/postconf.5.html#smtpd_tls_dh1024_param_file
# http://www.postfix.org/postconf.5.html#smtpd_tls_dh512_param_file
# http://www.postfix.org/postconf.5.html#smtpd_tls_eecdh_grade
# Diffie-Hellman
smtpd_tls_dh1024_param_file = /etc/postfix/dh_1024.pem
smtpd_tls_dh512_param_file = /etc/postfix/dh_512.pem
smtpd_tls_eecdh_grade = strong
vérifier un certificat
openssl verify -purpose sslclient votre_certificat.cert
Si vous avez des améliorations à apporter, n’hésitez pas à me contacter par e-mail (karchnu CHEZ karchnu POINT fr).
EDIT: changement de configuration suivant les diverses failles survenues récemment.
Merci à cet article pour apprendre à gérer les certificats.
IsoHybrid copain !
isohybrid --partok tonimage.iso; dd if=tonimage.iso of=/dev/sdXY
Et voilà, on n’en parle plus ! Pour i686 et amd64 only.
]]>Si vous avez installé Ubuntu sur un PC à côté de Windows (en dual boot), et que vous ne pouvez pas y accéder, malgré une installation réussie, ces quelques lignes pourraient vous servir (le PC doit être relié au net).
Démarrez Ubuntu depuis une live USB ou un live CD. Ouvrez un terminal, et tapez :
sudo add-apt-repository ppa:yannubuntu/boot-repair && sudo apt-get update
sudo apt-get install -y boot-repair && (sudo boot-repair &)
Vous pouvez maintenant utiliser ‘boot-repair’. Cliquez sur “Recommended repair”. Une fois la réparation terminée, notez au cas où l’URL qui vous sera indiquée (paste.ubuntu.com/XXXXX). En cas d’erreur, vous devrez la communiquer pour obtenir de l’aide.
Redémarrez votre PC, vous devriez retrouver GRUB et pouvoir (enfin) accéder à Ubuntu !
À rajouter dans le .vimrc
:
au FileType xml setlocal equalprg=xmllint\ --format\ --recover\ -\ 2>/dev/null
Merci à ce post.
]]>Voilà comment mettre les accents Français (!) sur Putty quand on est en environnement hostile.
On peut mettre ceci dans le fichier .bash_profile
:
echo -ne '\e%G\e[?47h\e%G\e[?47l'
Et on peut également paramétrer Putty : Configuration -> Window -> Translation -> UTF-8
.
Merci à ce post.
]]>Si vous ne pouvez pas vous passer de Vim, mais que vous devez un jour travailler sous Windows (la vie est mal faite), sachez que vous pouvez utiliser gVim. Et pour le personnaliser, comment savoir où placer son vimrc ?
Il suffit de faire :echo $HOME
sous GVim pour avoir la réponse !
ATTENTION, le fichier doit être nommé _vimrc et non pas .vimrc.
]]>Ubuntu décide bêtement d’attendre la conf’ réseau avant de booter ? Ok, on supprime ça.
Suffit d’aller commenter quelques lignes dans /etc/init/failsafe.conf
(sleep).
Solution trouvée sur ce site.
]]>Non, je n’ai pas trouvé de titre plus court ! :p
Méthode testée pour récupérer l’un des éléments d’une image avec Gimp, lui appliquer un fond transparent, et redimensionner l’image pour n’avoir plus que l’élément voulu :
Si vous êtes à la recherche d’un logiciel facile d’utilisation pour fusionner plusieurs fichiers pdf en un seul fichier de plusieurs pages, je vous suggère de tester pdfsam.
Son fonctionnement est très intuitif : choisissez “Merge/Extract”, cliquez sur “Add” pour sélectionner les fichiers concernés, définissez le nom du nouveau fichier dans “Destination output file”, puis cliquez sur “Run”.
EDIT : à aujourd’hui (août 2013), il semblerait que pdfsam ait quelques problèmes dans sa version récente. Pour le remplacer, j’ai testé PDF Mod (paquet pdfmod) : son fonctionnement est encore plus intuitif, on peut facilement supprimer ou déplacer des pages… Je vous le conseille !
]]>Voici 3 commandes SQL bien pratiques, pour changer l’URL d’un blog WordPress. Il suffit de remplacer ‘http://www.ancien-site.com’ et ‘http://www.nouveau-site.com’ par les valeurs appropriées dans votre cas.
UPDATE wp_options SET option_value = replace(option_value, 'http://www.ancien-site.com', 'http://www.nouveau-site.com') WHERE option_name = 'home' OR option_name = 'siteurl';
UPDATE wp_posts SET guid = replace(guid, 'http://www.ancien-site.com','http://www.nouveau-site.com');
UPDATE wp_posts SET post_content = replace(post_content, 'http://www.ancien-site.com', 'http://www.nouveau-site.com');
Vestibulum leo turpis, dignissim quis ultrices sit amet, iaculis ac ligula. Pellentesque tristique, velit eget scelerisque scelerisque, est dolor ultrices arcu, quis ullamcorper justo arcu luctus mauris. Integer congue molestie nisi id posuere. Fusce pellentesque gravida tempus. Integer viverra tortor nec eros mollis quis convallis sem laoreet. Nulla id libero ac erat varius laoreet. Proin sed est est. Curabitur lacinia fermentum lorem, elementum malesuada ipsum malesuada ut. Donec suscipit elit id leo vehicula mattis non sed leo. Morbi varius eleifend varius. Nulla vestibulum, neque vitae aliquam eleifend, nisi tellus placerat nunc, quis suscipit elit turpis eu tortor. Etiam euismod convallis lectus quis venenatis. Phasellus laoreet magna in nibh cursus eu egestas nulla convallis. Aliquam vel ullamcorper risus. Fusce dictum, massa id consequat viverra, nulla ante tristique est, a faucibus nisi enim nec dui. Donec metus ligula, condimentum at porttitor eget, lobortis at quam.
Aenean vel libero in magna ultricies congue in a odio. Donec faucibus rutrum ornare. Fusce dictum eleifend fermentum. Vestibulum vel nibh a metus porttitor rhoncus. Pellentesque id quam neque, eget molestie arcu. Integer in elit vel neque viverra ultricies in eget massa. Nam ut convallis est. Pellentesque eros eros, sodales non vehicula et, tincidunt ut odio. Cras suscipit ultrices metus sit amet molestie. Fusce enim leo, vehicula sed sodales quis, adipiscing at ipsum.
Nunc tempor dignissim enim, sed tincidunt eros bibendum quis. Curabitur et dolor augue, id laoreet mi. Nulla cursus felis id dui vehicula vitae ornare lorem blandit. Cras eget dui nec odio volutpat pharetra. Fusce hendrerit justo justo, vel imperdiet enim. Vivamus elit risus, interdum ultrices accumsan eleifend, vestibulum vitae sapien. Integer bibendum ullamcorper tristique. Nulla quis odio lectus, quis eleifend augue. Integer a ligula mauris. Aenean et tempus tortor. Quisque at tortor mi. Vivamus accumsan feugiat est a blandit. Sed vitae enim ut dolor semper sodales. Duis tristique, ante et placerat elementum, nulla tellus pellentesque sapien, quis posuere velit mi eget nulla. Sed vestibulum nunc non est porttitor ut rutrum nibh semper. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
Nulla adipiscing ultricies lobortis. Vivamus iaculis nisl vitae tellus laoreet vitae aliquet lacus mollis. Phasellus ut lacus urna, sed sagittis ante. Etiam consectetur pretium nisl sed dignissim. Pellentesque convallis, nisl eget commodo mollis, sem magna consequat arcu, sed pretium ipsum arcu sit amet neque. Aliquam erat volutpat. Morbi sed mi sed urna vestibulum placerat vitae vel metus. Fusce ac ante at justo pharetra vehicula. Vivamus vel tortor eget augue aliquet aliquet at vel odio. Nunc venenatis, magna quis facilisis fringilla, augue tellus varius neque, in vulputate est eros ut tortor. Duis lorem neque, aliquam congue posuere id, condimentum non dui. Phasellus ut dui massa, porttitor suscipit augue. Praesent quis tellus quam, vel volutpat metus. Vivamus enim est, aliquam in imperdiet et, sagittis eu ligula. Vestibulum hendrerit placerat orci et aliquet. Cras pharetra, dolor placerat lobortis tempor, metus odio cursus ligula, et posuere lacus ligula quis dui.
Donec a lectus eu nibh malesuada aliquam. Proin at metus quam, et tincidunt leo. Quisque lacus justo, scelerisque sodales pulvinar sed, dignissim ut sapien. Vivamus diam felis, adipiscing sollicitudin ultricies id, accumsan ac felis. In eu posuere ligula. Suspendisse potenti. Donec porttitor dictum dui id vehicula. Integer ante velit, congue id dictum et, adipiscing a tortor.
Une commande pratique pour renommer un ensemble de fichiers : rename.
Par exemple, pour remplacer tous les espaces par des underscores sur les fichiers .truc :
rename 's/ /_/g' *.truc
Si vous voulez vous rassurer, vous pouvez prendre un fer à cheval vérifier au préalable quels changements vont être faits en ajoutant l’option -n (les changements ne seront alors pas effectués) :
rename -n 's/ /_/g' *.truc
Et comment faire si on veut également appliquer le changement dans les sous-dossiers (et les sous-sous-dossiers ;) ) ? Voilà un exemple de script que vous pouvez utiliser (dans cet exemple, on cherche à remplacer les espaces par des underscores dans les fichiers .odt ou .ods) :
#!/bin/bash
rep=$(pwd)
IFS=$'\n'
for i in $(find . -name "*.odt" -or -name "*.ods")
do
dirname=`dirname ${i}`
basename=`basename "${i}"`
cd ${dirname}
rename 's/ /_/g' ${basename}
cd ${rep}
done
Fusce tortor quam, egestas in posuere quis, porttitor vel turpis. Donec vulputate porttitor augue at rhoncus. Proin iaculis consectetur sagittis. Curabitur venenatis turpis sit amet purus tristique nec posuere risus laoreet. Nullam nisi sem, dapibus id semper id, egestas vel arcu. Morbi porttitor ipsum placerat erat consequat sed consequat purus feugiat. Donec auctor elit ut risus mattis facilisis. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Proin vulputate sapien facilisis leo ornare pulvinar. Fusce tempus massa a risus semper iaculis. Suspendisse sollicitudin posuere nunc, sit amet rutrum leo facilisis mattis. Sed ornare auctor dui, vitae rutrum neque auctor sit amet. Proin ac dui magna. Mauris vehicula interdum augue, nec ultrices libero egestas quis. Nunc convallis euismod ipsum, id sollicitudin orci consequat ac. Fusce bibendum congue libero, in rutrum nulla congue non. Cras sit amet risus tortor, eu pellentesque dui. Phasellus euismod enim non nibh sodales quis consectetur lorem laoreet. Vivamus a egestas quam. Curabitur in tortor augue, vitae varius tellus. Integer varius, elit ac gravida suscipit, eros erat pellentesque nisi, et tristique augue odio id nulla. Aliquam sit amet nunc vel tellus hendrerit tempus ac vel sem.
Aenean tincidunt sollicitudin sapien ut porttitor. Curabitur molestie adipiscing lorem vel scelerisque. Donec vitae interdum est. Proin rutrum vulputate faucibus. Suspendisse sit amet felis odio, non volutpat ante. Sed eu lectus quam. Curabitur tristique rhoncus est, vel commodo tortor suscipit semper. Maecenas feugiat vestibulum nisi id facilisis. Nulla non tincidunt libero. Praesent ultrices interdum commodo. Sed euismod nisl auctor leo ultrices rutrum. Aliquam nibh felis, congue molestie blandit at, bibendum at eros. Aenean tincidunt, tortor iaculis placerat sollicitudin, lorem justo tempor diam, et posuere sapien leo et magna. Quisque vel aliquam mauris.
Proin varius tempus fermentum. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed tincidunt nunc id magna adipiscing non sollicitudin turpis tempor. Etiam vel elit ipsum, quis euismod velit. Quisque elementum magna vitae quam venenatis lacinia. Sed at arcu ipsum. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Donec ut lorem ac sapien cursus lacinia sit amet mollis dolor. Vivamus tempus odio nec magna faucibus sed hendrerit lorem tempor.
Vestibulum eu nisi arcu. Curabitur nisi risus, fermentum ut lacinia ut, interdum nec magna. Nunc aliquet gravida massa, eu aliquam lorem faucibus at. Sed sollicitudin volutpat velit id tempor. In nibh justo, pharetra et pretium dignissim, tempus in turpis. Phasellus eget lobortis nisl. Phasellus sed fermentum diam. Nam tempus pharetra odio, quis congue eros imperdiet eu. Aliquam dui eros, hendrerit et vulputate vel, porta eu eros. Nullam nisi dui, commodo eget pharetra ut, ornare sit amet nunc. Fusce vel neque urna. Maecenas nulla ante, egestas at consequat quis, fermentum a enim. Aliquam id tristique urna. Integer augue justo, scelerisque et consectetur id, rhoncus eget enim.
Vous utilisez Thunderbird et vous avez configuré des filtres de messages pour l’un de vos comptes de messagerie ? Vous souhaitez avoir les mêmes filtres pour vos autres comptes ?
C’est facile ! Il suffit de tout recopier à la main !
Ou alors vous pouvez toujours jeter un oeil dans votre ~/.thunderbird et copier le fichier msgFilterRules.dat d’un compte à l’autre.
C’est vous qui voyez ! ;)
J’avais un soucis de son, j’ai deux cartes détectées. Ça se traduit par un problème avec mplayer :
[AO_ALSA] alsa-lib: pcm_hw.c:1293:(snd_pcm_hw_open) open '/dev/snd/pcmC0D0p' failed (-2): No such file or directory [AO_ALSA] alsa-lib: pcm_dmix.c:1018:(snd_pcm_dmix_open) unable to open slave
Et avec amixer :
ALSA lib pcm_dmix.c:1018:(snd_pcm_dmix_open) unable to open slave
Le soucis : deux cartes son sont détectées. Il faut que la seconde soit la première chargée. Pour détecter les cartes : hwinfo --sound
(à installer). Il y a un identifiant, on va l’utiliser.
On ouvre
/etc/modprobe.d/audio.conf
et on y met :
options snd-hda-intel id=second-identifiant-trouvé-avec-hwinfo index=0
options snd-hda-intel id=premier-identifiant-trouvé-avec-hwinfo index=1
On a donc inversé les deux cartes, la seconde est chargée comme étant la première (et donc celle par défaut), le son fonctionne correctement.
]]>Suspendisse pharetra ullamcorper sem et auctor. Suspendisse vitae tellus eu turpis dignissim gravida ut ut tortor. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Morbi aliquam sapien quis nisl sodales non aliquet nisl iaculis. Curabitur fermentum orci vel sapien pellentesque id condimentum metus vehicula. Curabitur turpis purus, scelerisque at interdum quis, placerat sit amet tortor. Aliquam erat volutpat.
Integer posuere felis non arcu suscipit ullamcorper. Nam tempus risus venenatis orci sagittis eu aliquam ante tincidunt. Aenean vehicula ipsum id sapien tincidunt commodo. Aliquam erat volutpat. Curabitur vehicula libero ac turpis cursus consectetur. Praesent posuere egestas purus et dapibus. Mauris egestas, lectus vitae scelerisque ultricies, metus lorem tempor nisi, sed vehicula tortor mauris nec urna. Quisque urna tellus, facilisis at mollis eget, adipiscing in nisl. Proin quam arcu, euismod et imperdiet sed, ultricies sed orci.
Nulla malesuada sem eget lectus scelerisque nec rhoncus metus interdum. In dui felis, rhoncus id scelerisque eget, vulputate id sem. Nulla facilisi. Vestibulum eleifend, metus dignissim lacinia ornare, magna nulla vehicula nisi, sed molestie mauris ipsum vel turpis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nulla urna leo, vehicula eget dignissim a, hendrerit ut risus. Fusce ultricies elementum placerat. Nam at dolor sed nisi mollis sollicitudin vitae at urna. Vestibulum iaculis adipiscing eros et mollis.
Phasellus ultricies elit eu risus sagittis eu dictum ante ultrices. Nulla congue, augue ac placerat tempor, orci mi luctus nisi, at varius ipsum sem sed eros. Vivamus eget velit eget felis posuere ornare. In sed metus non est iaculis facilisis dapibus sit amet enim. Aliquam viverra tortor eget neque volutpat in auctor urna rutrum. Aliquam ligula augue, congue sit amet rutrum in, semper vel nulla. Sed tempus porttitor faucibus. Donec cursus sodales nulla, quis lacinia mi vehicula vel. Sed nec purus orci. Nam leo sapien, rutrum a ultrices quis, placerat vel ligula. Donec massa quam, pellentesque et molestie nec, hendrerit id mauris. In hac habitasse platea dictumst. Cras quis quam sem. Curabitur in arcu diam, in interdum mauris.
Proin lorem sapien, iaculis et faucibus nec, dictum sed nunc. Pellentesque in purus justo. Vestibulum facilisis rutrum nisi, a egestas nunc suscipit sed. Ut quis tortor a arcu bibendum placerat non sed ante. Praesent orci sem, posuere sit amet cursus molestie, volutpat ut purus. Curabitur aliquam, purus in pharetra viverra, lorem leo aliquam tellus, vel consequat felis neque et mauris. Aliquam erat volutpat.
Pour mémo, voici quelques commandes pour gérer les services avec systemd, testées sous Fedora 17 (exemple avec sshd) :
Pour activer un service au démarrage : systemctl enable sshd.service
Pour lancer le service, sans l’activer au démarrage : systemctl start sshd.service
Pour voir si le service est activé : systemctl is-enabled sshd.service
Pour voir si le service est lancé : systemctl status sshd.service
# yum install gnash
Puis : plug-in pour Firefox : # yum install gnash-plugin
Ou plug-in pour Konqueror : # yum install gnash-klash
Thunderbird fait un retour à la ligne tous les 72 caractères, on va changer ça : Edition > Avancé > Général > Éditeur de configuration
:
mailnews.wraplength → 0 et wrap_long_line à true
Pour installer le scanner de l’imprimante “Brother DCP-195C” sur Ubuntu 12.04 :
Passer en mode super-utilisateur.
Installer le programme Xsane si on ne l’a pas déjà, ainsi que les paquets libsane-extras, sane et sane-utils.
Aller sur ce lien pour télécharger le driver brscan3 (en 32 ou 64 bits selon votre architecture).
Mettre en route l’imprimante si ce n’est pas déjà fait.
Aller dans le répertoire dans lequel le driver a été téléchargé, et installer le driver :
dpkg -i --force-all [scanner-drivername]
dpkg -l | grep Brother
# Brother scanners
ATTRS{idVendor}=="04f9", ENV{libsane_matched}="yes"
Redémarrer l’ordinateur et l’imprimante pour que tout soit bien pris en compte.
On peut maintenant scanner avec le programme Xsane.
Voici la marche à suivre pour pouvoir chiffrer (et / ou signer) ses e-mails dans Thunderbird, en utilisant le protocole OpenPGP :
gpg2 --gen-key
gpg2 --armor --export "Prénom Nom" › cle.asc
gpg2 --armor --import cle.asc
On télécharge le module “Enigmail” dans Thunderbird.
Dans Thunderbird, on choisit “OpenPGP => Gestion de clefs”. Les clés doivent s’y trouver. On pourrait éventuellement rajouter une identité si on veut utiliser plusieurs adresses e-mails avec la même clé.
Dans “Édition => Paramètres des comptes”, choisir “Activer le support OpenPGP” et “Utiliser l’adresse électronique de cette identité pour identifier la clef OpenPGP”.
Lors de l’envoi d’un e-mail, on peut choisir de signer et / ou chiffrer le message en cliquant sur “OpenPGP”.
Alors c’est de l’info qu’elle est bonne :
/filter add joinquit * irc_join,irc_part,irc_quit *
Gain of productivity > 9000.
Si un site web vous demande d’installer Java, voici la marche à suivre (testée avec Ubuntu 12.04) :
Installez les paquets openjdk-7-jre
et icedtea-7-plugin
Redémarrez Firefox.
C’est tout ;)
]]>Mauris in lorem nisl. Maecenas tempus facilisis ante, eget viverra nisl tincidunt et. Donec turpis lectus, mattis ac malesuada a, accumsan eu libero. Morbi condimentum, tortor et tincidunt ullamcorper, sem quam pretium nulla, id convallis lectus libero nec turpis. Proin dapibus nisi id est sodales nec ultrices tortor pellentesque. Vivamus vel nisi ac lacus sollicitudin vulputate ac ut ligula. Nullam feugiat risus eget eros gravida in molestie sapien euismod. Nunc sed hendrerit orci. Nulla mollis consequat lorem ac blandit. Ut et turpis mauris. Nulla est odio, posuere id ullamcorper sit amet, tincidunt vel justo. Curabitur placerat tincidunt varius. Nulla vulputate, ipsum eu consectetur mollis, dui nibh aliquam neque, at ultricies leo ligula et arcu. Proin et mi eget tellus sodales lobortis. Sed tempor, urna vel pulvinar faucibus, lectus urna vehicula ante, at facilisis dolor odio at lorem. Morbi vehicula euismod urna, et imperdiet urna ornare vitae.
Sed tincidunt sollicitudin ultrices. In hac habitasse platea dictumst. Morbi ligula lectus, egestas at ultricies nec, fringilla et tellus. Duis urna lorem, bibendum a ornare sed, euismod sed nunc. Aliquam tempor massa at velit fringilla fringilla. Praesent sit amet tempor felis. Maecenas id felis ac velit aliquam tempor a sit amet orci. Nunc placerat nulla pellentesque sem commodo cursus. Praesent quis sapien orci, quis ultricies augue. Nam vestibulum sem non augue semper tincidunt pellentesque ipsum volutpat. Duis congue, nunc a aliquam luctus, quam ante convallis nisi, ac pellentesque lacus orci vel turpis. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Suspendisse hendrerit nisl eu felis sagittis faucibus. Nunc eu congue lorem. Quisque non nibh nisi, et ultrices massa. Sed vitae erat vitae nulla pellentesque fermentum.
Ut diam nunc, consectetur ut ultrices eu, iaculis sed felis. Sed lacinia, odio et accumsan luctus, arcu ipsum accumsan erat, sit amet malesuada libero lacus et velit. Donec accumsan tristique tristique. Proin a metus magna, vitae mattis nisl. Integer a libero ipsum. Mauris faucibus eleifend metus id sodales. Morbi ornare, nibh nec facilisis imperdiet, turpis sem commodo lorem, id commodo mauris metus vitae justo. Etiam at pellentesque tortor. Proin mollis accumsan ligula, nec tempus augue auctor quis. Nulla lacinia, mi quis lobortis auctor, nisi diam posuere dui, pulvinar feugiat dui libero eget quam. Fusce eu risus nunc, a consectetur orci. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Maecenas venenatis aliquet orci, a ultricies sem facilisis eu. Donec dolor purus, porta condimentum convallis nec, dignissim nec libero.
Etiam rutrum ultricies dui, et interdum metus elementum et. Nulla sapien nunc, interdum tristique porttitor in, laoreet vitae mi. Ut vehicula auctor mauris sit amet bibendum. Phasellus adipiscing mattis libero, eget adipiscing erat dignissim at. Vivamus convallis malesuada metus nec cursus. Ut cursus, lorem eleifend sollicitudin condimentum, felis tortor sodales augue, ac tempus lacus ipsum vitae quam. Vestibulum vitae lacus non tortor vehicula iaculis faucibus quis massa.
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Duis malesuada neque nec ante porttitor accumsan. Suspendisse potenti. Aliquam in lacus magna, imperdiet laoreet lectus. Praesent id diam nec ante commodo rhoncus nec vel augue. Pellentesque tortor massa, dignissim ut sagittis sed, hendrerit vitae nunc. Nam gravida, urna vitae hendrerit rutrum, felis augue vulputate tortor, ut varius velit libero nec lectus. In adipiscing massa in est scelerisque ullamcorper. Vivamus in nisi metus.
Voici les manipulations réalisées pour configurer l’imprimante Epson Stylus SX130 sur un ordi tournant sous Ubuntu 12.04 (sous Fedora, voir la note en bas de page) :
Brancher l’imprimante et la relier avec l’ordinateur (Mwahaha).
Un petit tour sur le site openprinting.org nous indique que le driver à utiliser pour cette imprimante est espon-201101w. On recherche ensuite sur le site d’Epson les drivers pour notre imprimante sous Linux, et on arrive sur cette page. On télécharge le paquet correspondant à notre architecture (dans mon cas epson-inkjet-printer-201101w_1.0.0-1lsb3.2_i386.deb). On ouvre ensuite un terminal en tant que root et on fait “apt-get install lsb” (on sera sinon confronté à un problème de dépendance), puis “dpkg -i” de notre paquet .deb.
On se connecte sur l’interface de Cups (http://localhost:631/). Administration -> Imprimantes -> Ajouter une imprimante => Sélectionner “Epson Stylus SX130” qui apparaît dans la liste des imprimantes locales. A la fin de la configuration, on vous demande de choisir le modèle de l’imprimante. Il suffit de choisir “Stylus SX130” qui est bien dans la liste grâce à la manip’ précédente !
Félicitations, vous pouvez désormais imprimer ! Si vous souhaitez pouvoir également scanner (tant qu’à faire ;) ), voici la marche à suivre :
Télécharger depuis ce site les drivers pour le scanner. Choisissez les versions les plus récentes des paquets iscan ET iscan-data qui correspondent à votre architecture (dans mon cas iscan_2.29.1-5~usb0.1.ltdl7_i386.deb et iscan-data_1.16.0-3_all.deb).
Connectez-vous à un terminal en tant que root et effectuer les actions suivantes dans cet ordre (pour éviter là encore d’être confronté à un problème de dépendances) : “apt-get install xsltproc” ; puis “dpkg -i iscan-data_(…).deb” ; et enfin “dpkg -i iscan_(…).deb”.
C’est fini, vous pouvez désormais numériser vos documents ! :) En cas d’échec, redémarrez l’imprimante, et essayez à nouveau.
EDIT : petite note rapide. Je viens de tester avec Fedora 17, ça marche (en utilisant Image Scan! for Linux pour les scans). Il faut bien sûr choisir les paquets .rpm au lieu de .deb et utiliser les commandes appropriées (rpm -i paquet.rpm et yum install paquet_sur_les_depots). Le paquet xsltproc n’est pas à installer. Enfin, il faut se connecter en tant que root à l’interface de cups.
Petite astuce si vous êtes un utilisateur de GitHub, et que, malgré avoir indiqué votre clé publique sur votre compte, on vous demande de vous identifier à chaque fois sur le dépôt (Username for ‘https://github.com’: et Password for ‘https://pseudo@github.com’)…
Il suffit de modifier le fichier .git/config , et de remplacer “url = https://github.com/pseudo/depot.git” par “url = git@github.com:pseudo/depot.git”
Et voilà, ça peut toujours servir ! :)
Sous Thunderbird, pour recevoir uniquement les messages provenant des contacts enregistrés dans son carnet d’adresses :
On crée un filtre. Outils => Filtre de messages => Nouveau. Condition : les messages “de” “n’est pas dans mon carnet d’adresses (personnelles / ou collectées)”. Action : Supprimer.
On fait en sorte que les messages ne provenant pas de ses contacts soient automatiquement supprimés (sans transiter par la corbeille). Édition => Paramètres des comptes => Paramètres du serveur. “Lorsque je supprime un message => le supprimer immédiatement.”
Et voilà c’est bête comme chou ! :P
Voici un billet de blog pour indiquer mon expérience sur ce type de matériel et OpenWRT.
Pour installer OpenWRT sur un TP-LINK MR3020 : télécharger le firmware à installer.
On peut se connecter via le navigateur au site sur le tp-link (admin/admin) et indiquer le firmware openwrt comme étant une mise à jour du firmware.
De là, installation par défaut d’OpenWRT, faut faire un telnet, changer le mot de passe etc. comme indiqué sur le site d’OpenWRT (First Loging), puis faire quelques conf’ (notamment accès au net) puis on se fait un sysupgrade. Pour ça, faut télécharger le .bin pour un sysupgrade et à partir de là, plus aucun soucis comme quoi le kernel n’est pas bon (lors de l’installation de divers paquets etc.).
Maintenant faut faire toutes nos installations de paquet sur un clef USB à part (16G c’est toujours mieux que 4Mio non ?).
À suivre !
Tout se fait simplement.
Le lien qui m’a permis de trouver comment installer les drivers + configurer le wifi : Post sur ubuntuforums.org
On veut configurer notre imprimante en wifi, donc on va sur sa box (livebox, freebox etc.) et on change le SSID en BJNPSETUP
.
Maintenant on presse le bouton de maintenance de l’imprimante jusqu’à voir un ‘G’ sur le petit écran digital (sans la barre horizontale du G), ensuite on appuie sur l’impression couleur.
Là l’imprimante va chercher à se connecter à la box.
Une fois que c’est fait, on va essayer de trouver l’adresse de l’imprimante qui répond au réseau (elle répond aux requêtes ping !).
Une fois qu’on a trouvé son IP, on ouvre notre navigateur web et on s’y connecte en entrant son IP, à partir de là on pourra la configurer comme il faut.
Ensuite on n’a plus qu’à installer les drivers (ceux donnés au dessus) en décompressant les bonnes archives / sous-archives et en exécutant “install.sh”.
Et voilà !
Concernant le scanner : il faut exécuter le programme scangearmp
.
Si vous souhaitez rétablir la configuration par défaut, pour recommencer l’opération (changement de box par exemple), il faut taper 14 fois sur le bouton de maintenance (on verra la lettre “t” s’afficher) et appuyer sur “Color”.
Quand on est sur IRC et que quelqu’un a déjà notre pseudo, pour s’enregistrer on fait :
bash /msg C nick ghost votrevraipseudo motdepasse /nick votrevraipseudo /msg C nick identify motdepasse
bash
On veut parfois changer toutes les lettres majuscules par leur équivalent en minuscule et inversement.
Pour la ligne courante :
:.!tr '[A-Z][a-z]' '[a-z][A-Z]'
Pour une autre sélection ça marche comme avant.
Pour changer la date sous linux :
date MMDDhhmmYY.ss
Mois Jour Heure Minute Année Seconde
Alors là je me dis que celui qui a fait cette commande est forcément un américain vu la logique imparable qui a poussé le développeur à foutre l’année entre les minutes et les secondes.
Après :
date -s HH:MM:SS : pour changer uniquement l'heure
date -s MM/JJ/AAAA : pour changer uniquement la date
Ensuite il faut synchroniser la date du système avec celle de l’horloge matérielle (celle du BIOS) :
hwclock --systohc
Pour utiliser une coloration syntaxique que vous avez choisi :
:set filetype=fortran
Pour accéder à l’interface web de cups, pour configurer et gérer les imprimantes :
http://localhost:631/
Pour grep, l’option -o permet de n’afficher que ce qu’on recherche.
Exemple dans un fichier sql où j’ai préfixé toutes les contraintes (Foreign key : fk etc.) ça donne :
grep -E '(fk|pk|u)_\w' fichier.sql -o | sort
Pour connaître le nom ou le numéro ASCII d’une touche, il existe un programme simple (et que j’ai par défaut sur ma ArchLinux) : xev
.
ssh-keygen -t dsa
cat ~/.ssh/id_dsa.pub | ssh remote "cat >> .ssh/authorized_keys2"
Une indentation pourrie de code vous a été envoyé par le détraqué qui est sensé vous apprendre à pisser du code ?
indent -bli 0 prog.c
On y verra déjà plus clair.
Et ne pas faire ça sur un FUCKING Makefile.
Yaourt n’a pas fonctionné lors d’une mise à jour. Pour ignorer les paquets qui plantent (genre une dépendance qui n’est pas satisfaite etc.), il suffit de passer par Pacman et non Yaourt.
pacman -Su
Rien de plus compliqué.
http://opentrackers.net/
Permet de voir une bonne grosse liste de trackers privés. Il y en a pour tous les goûts.
]]>Voici un bug qui m’est arrivé :
error while loading shared libraries: libaudiofile.so.0: cannot open shared object file
Voici la solution que j’ai trouvé (mais pas sûr que ce soit très propre cependant):
cd /usr/lib/
ln -s libaudiofile.so.1.0.0 libaudiofile.so.0
Il faut exporter ses contacts puis sur le fichier on fait un :
sed 's/,/;/g' fichier
Voilà. Manque plus qu’à l’importer.
Il faut installer p7zip puis la commande c’est 7z [option] fichier.
OPTION = “x” si on souhaite respecter l’arborescence en décompressant. “e” sinon.
Utilitaire : escputil
-c : nettoyage des têtes d'impression ;
-i : obtenir le niveau d'encre ;
Pour vous faire entendre sur tous les canaux :
/allchan -except=weechat msg * votre message
Ça peut sembler stupide, mais j’ai pas trouvé tout de suite comment faire.
Bientôt : un guide de ce dont je me sers sur weechat / whatever.
Voilà. Ça nous arrive à tous de travailler avec screen (il le faut) mais le soucis c’est que c’est super chiant d’avoir un clignotement blanc à chaque fois qu’on se trompe dans une touche ou qu’on revient en arrière.
Solution : "vbell off"
dans .screenrc
.
À noter : screen-launcher, qui permet d’avoir quelques screenrc pré-configurés.
Des gens partagent leur screenrc ici : http://forum.ubuntu-fr.org/viewtopic.php?id=390985.
Un exemple :
# programmes à lancer
screen -t Bandepassante 0 sh /home/qid/.scripttrafiquereseau.sh
screen -t Ordinateur 1 htop
split -h
screen -t Apache 2 bash -c 'tail -F /var/log/apache2/access.log | ccze'
select Apache
focus down
screen -t Jabber 3 bash -c 'tail -F /var/log/ejabberd/ejabberd.log | ccze'
select Jabber
screen -t IRC 4 weechat-curses -d /home/qid/.weechat/serveur/
screen -t Libre 5 bash
screen -t DateHeure 6 bash -c 'watch -n1 "banner \$(date +"%X%n%^A%n%x%n%nCtrl-A_D")"'
Voici comment avoir un serveur VPN via openvpn de manière vraiment simple mais pas super si vous souhaitez connecter 10 machines.
Tout d’abord on installe openvpn via votre gestionnaire de paquet préféré et on va dans /etc/openvpn
(on crée le répertoire s’il n’existe pas).
Là on crée une clé partagée :
openvpn --genkey --secret static.key
scp static.key autre_ordinateur
Ensuite sur le même ordinateur (le serveur) :
vim /etc/openvpn/serveur.cfg
dev tun
ifconfig 10.0.0.1 10.0.0.2
secret /etc/openvpn/static.key
Pour le client c’est la même chose sauf qu’on rajoute la ligne “remote nom_serveur” en haut et qu’on écrit les adresses de la ligne ifconfig dans l’autre sens. Oh et puis tant que j’y suis, voilà :
vim /etc/openvpn/client.cfg
remote nom_serveur
dev tun
ifconfig 10.0.0.2 10.0.0.1
secret /etc/openvpn/static.key
Maintenant on active la liaison :
openvpn --config /etc/openvpn/serveur.cfg > /var/log/vpn
La même chose avec le client mais “client.cfg” cette fois ;) .
Et voilà, si on lance un p’tit tcpdump on doit voir des paquets qui passent (si on fait un ping 10.0.0.1 à partir du client par exemple).
tcpdump -n -i tun0 host 10.0.0.2 and host 10.0.0.2
]]>rfkill et plus de soucis wifi / dent bleue etc.
Ce logiciel désactive tout ça en faisant un simple :
rfkill block all
Pour désactiver les bips de la carte mère sous BSD :
sysctl hw.syscons.bell=0
Pour que ce soit fait au démarrage, on rajoute une ligne au fichier /etc/sysctl.conf
:
hw.syscons.bell=0
Voilà, ça casse plus les c*#!$.
]]>Comment utiliser différents canaux via mplayer :
Là on utilise les cartes par défaut:
mplayer -ao oss *.flac
mplayer -ao alsa *.flac
Là on n’utilise pas les cartes par défaut :
mplayer -ao oss:/dev/dsp1 *.flac
mplayer -ao alsa:device=hw=1.0 *.flac
]]>Mettre de la couleur dans Bash !!!
On met \033[CODECOULEURm
Le-texte-à-écrire\033[00m
Couleur normale. Avec CODECOULEUR : commence par 3 pour l’écriture, 4 pour le fond. Pour revenir aux couleurs par défaut : 00.
0 Noir
1 Rouge
2 Vert
3 Orange
4 Bleu
5 Magenta
6 Cyan
7 Blanc
Pour le texte : 01 gras, 04 sous-ligné, 05 clignotant, 07 Sur-ligné.
Exemple: echo -e “33[31m33[44mRouge sur bleu.33[00m”
Avec ça on a des jolis couleurs dans notre bash pour les scripts qu’on fait !
]]>Pour utiliser un processeur AMD A4-3300 (et d’autres “APU” CÀD des processeurs contenant une partie “carte graphique”), il faut installer les pilotes propriétaires sous peine de devoir se taper le pilote vesa et une résolution de 1024x768.
Déjà, catalyst ne supporte pas KMS, donc au démarrage il faut ajouter “nomodeset” aux options passés au noyau dans grub.
C’est parti :
yaourt -S catalyst
modprobe -r radeon
Faudra blacklister ça dans /etc/modprobe.d/radeon_blacklist.conf
blacklist radeon
Ensuite on revient dans la console
modprobe fglrx
aticonfig --initial --input=/etc/X11/xorg.conf
Puis faudrait faire en sorte de pas avoir à taper nomodeset dans grub à chaque démarrage. Pour Debian à mettre dans /etc/apt/sources.list/
:
deb http://ftp.fr.debian.org/debian squeeze main contrib non-free
Puis :
aptitude install linux-headers-2.6-$(uname -r | sed 's,.*-,,')
aptitude install fglrx-control fglrx-driver fglrx-glx fglrx-modules-dkms
invoke-rc.d gdm3 stop
modprobe -r radeon drm
aticonfig --initial
Ensuite, modification de xorg.conf :
Section "Device"
Identifier "ATI"
Driver "fglrx"
EndSection
Section "Screen"
Identifier "Default Screen"
DefaultDepth 24
EndSection
Et on redémarre l’interface :
invoke-rc.d gdm start
]]>On souhaite lancer un programme qui ne soit pas attaché au terminal courant.
Bash: disown
Zsh : &!
ou &|
Exemple : lancement d’un rsync un peu long
rsync -avz grokonteunu monserveur:~
Là on se dit “je suis en ssh, je veux exécuter d’autres trucs, et pas que tout s’arrête si je perds la connexion !”.
^z
bg %1
disown -
Voilà c’est bon, la commande est détachée.
Pour zsh :
rsync -avz grokonteunu monserveur:~ &!
On est tranquille. ☺
]]>Vous souhaitez utiliser un dictionnaire français pour ne plus avoir d’erreur dans ce que vous écrivez :
:set spell spelllang=fr_FR
Voilà, maintenant on répond gentiment au petit script qui demande où on va mettre le dictionnaire.
Passons à l’utilisation.
En mode insertion.
Demander la liste des complètements (complétions) suivant le dictionnaire :
^x ^k
Naviguer dans la liste proposée :
^p OU ^n
Utilisation un peu plus avancée, en mode normal. Positionner le curseur sur le mot hors du dictionnaire suivant :
]s
Positionner le curseur sur le mot hors du dictionnaire précédent :
[s
Suggestions de correction pour le mot hors dictionnaire placé sous le curseur :
z=
L’appel de z=
vous donne une liste de corrections numérotées, il ne manque qu’à donner le bon numéro.
Recherche toutes les lignes de l’expression rationnelle A à l’expression B :
awk '/start_pattern/,/stop_pattern/' file.txt
De rien.
]]>Ce que je cherchais : exécuter des commandes complexes à distance. Solution :
ssh host $(<cmd.txt)
Où j’ai trouvé ça : http://blog.urfix.com/25-ssh-commands-tricks/
D’autres informations pratiques sont dispo comme :
ssh -N -L2001:localhost:80 somemachine
Permet de créer un tunnel ssh de votre “localhost” au port 2001 vers le port 80 d’une autre machine. Et ça, c’est nice.
]]>Pour connaître le temps de musique que vous avez dans votre bibliothèque mpd :
mpc stats
Ou via ncmpcpp
@
]]>Installation de pm-utils + pm-suspend
en root. Voilà.
Comment récupérer une page en un document pdf de façon ultra simple : wkhtmltopdf.
wkhtmltopdf http://monsiteouaib.com/ monsiteouaib.pdf
De rien.
]]>Voici comment installer “ladistribution”, qui contrairement à son nom n’est PAS une distribution.
Cela permet de s’installer rapidement de façon très graphique wordpress, un serveur firefox-sync, un forum et tout un tas d’autres trucs cool.
Tout d’abord, installer apache2 + php5 + mysql :
apt-get update && apt-get install apache2 php5 mysql-server php5-mysql
Ensuite on active l’url rewriting :
a2enmod rewrite
Dans le fichier /etc/apache2/sites-enabled/000-default
on remplace entre les tags “Directory /var/www
” “AllowOverride None” par “AllowOverride All”. Maintenant on se place dans /var/www , on télécharge le fichier d’installation :
wget http://ladistribution.net/installer/installer.txt
mv installer.txt installer.php
chown www-data:www-data . -R
Maintenant on va ajouter un utilisateur à notre serveur mysql :
mysql -u root -p
votremotdepasse
mysql> CREATE user "nom_de_votre_utilisateur"@localhost;
mysql> SET password FOR "nom_de_votre_utilisateur"@localhost = password('votremotdepasse');
On crée une base de données pour ladistribution et on donne les droits à notre utilisateur :
mysql> CREATE DATABASE ladistrib;
mysql> GRANT ALL ladistrib.* TO "nom_de_votre_utilisateur"@localhost;
Maintenant on se connecte (enfin !) sur le site http://localhost/installer.php On suit ce qui est marqué (ça prend 30 secondes).
Voilà, vous pouvez aller sur la page “home” puis ajouter des “apps”. Firefox Sync, wordpress, etc.
Enjoy !
vboxsf est le module pour créer des répertoires partagés entre l’host et le guest.
Soucis : sur Archlinux ce module n’a pas été compilé pour la dernière version du noyau.
Pas de soucis, on va se faire un truc tout crade :
insmod /lib/modules/2.6.32-5-668/updates/dkms/vboxsf.ko
mount -t vboxsf shared_folder /mnt/shared_folder
Et ça marche.
]]>Voilà, rien de particulier à dire. Mood thread !
Voici comment faire pour avoir son dépôt Git @ home, par une méthode simple à mettre en place.
D’autres méthodes sont disponibles, mais sont plus difficiles à mettre en place. Ce que j’ai fait chez moi c’est ajouter un utilisateur à mon serveur (git), ajouter ma clé à authorized_keys2 et créer des dépôts vides pour qu’on puisse les utiliser.
Voici comment faire. Tout d’abord, nouvel utilisateur :
useradd -m -s /bin/bash -d /home/git git
Pour passer par ssh sans entrer de mot de passe, sur le poste client :
ssh-keygen -t rsa
On ajoute le contenu du fichier ~/.ssh/id_rsa.pub
à la suite du fichier /home/git/.ssh/authorized_keys
sur le serveur.
scp ~/.ssh/id_rsa.pub git@monserveur.com/~/.ssh/id_karchnu.pub
ssh git@monserveur.com
cat ~/.ssh/id_karchnu.pub >> ~/.ssh/authorized_keys2
Puis on crée un dépôt vide dans lequel on mettra notre projet (sur le serveur !) :
mkdir monprojet.git ; cd monprojet.git ; git --bare init
L’option --bare
signifie qu’il n’y a pas de “working directory”. Côté utilisateur, dans le projet.
git remote add home ssh://git@monserveur.com/home/git/monprojet.git
git push home master
Fin.
Bon, ce post est plus un mémo pour ceux qui connaissent déjà mais qui ont oublié… car un peu technique et pas d’explications ! :D Petit détail : couplé à mon article précédent (à propos de Trac), vous avez un environement de dév. plutôt complet.
Enjoy !
]]>Depuis un petit moment je cherche à avoir un dépôt git public avec une interface agréable, un peu comme GitHub (pas libre, beuuuuuurk). Maintenant c’est fait avec Trac et le plugin git (par défaut il utilise svn).
Il faut préparer son dépôt Git :
mkdir /srv/git/
cd /path/to/git/repo/ ; cd .. ; git clone --bare mondépôt
mv mondépôt.git/ /srv/git/
Ensuite, on va installer trac (ubuntu) :
apt-get install trac-git
Ce qui installera tout un tas de trucs, et de machins.
On va créer un répertoire Track :
trac-admin /path/to/repo/ initenv
cd <path> ; vim conf/trac.ini
et modifier :
repository_dir = /srv/git/mondépôt.git/
repository_type = git
pour terminer la configuration minimale, il faut ajouter à la fin du fichier :
[components]
tracext.git.* = enabled
Maintenant on va tester la configuration :
tracd --port 8000 /path/to/repo/
Si tout marche bien :
tracd -s --port 8000 /path/to/repo/
Bien sûr, il y a possibilité de passer par un “vrai” serveur web tel qu’apache ou nginx, pour ça, je vous laisser aller voir la configuration sur le site officiel de Trac.
Une chose à savoir : impossible de faire de “push”. Pour autoriser “git” à modifier un dépôt, il faut passer par ssh / gitosis. Plus d’info.
]]>Petit tips pour vim : pouvoir lire et écrire en hexa avec VIM ! 1) ouvrir le fichier, 2)
:%!xxd
Pour enlever le mode hexa :
:%!xxd -r
Et pour mapper tout ça :
nnoremap <c-h> :Hexmode<cr>
inoremap <c-h> <esc>:Hexmode<cr>
vnoremap <c-h> :<c-u>Hexmode<cr>
Tout ça a été vu sur : http://vim.wikia.com/wiki/Improved_hex_editing
]]>Voici comment désactiver les commentaires sur wordpress:
UPDATE wp_posts SET comment_status = "closed" WHERE comment_status = "open"
Plus de 800 spams pour 3 vrais commentaires. Fuck.
Désormais les commentaires sont désactivés, vous pouvez cependant m’envoyer des e-mails. N’hésitez pas !
Commande fort simple et ô combien utile :
sed -i 's/ancien/nouveau/g' fichier
Pour vérifier la modification :
grep --color=auto 'nouveau' fichier
C’est joli et utile !
PS : astuce pour les regex : -r
pour les regex étendues !
Today, on va vite voir comment monter un répertoire distant via ssh.
Tout d’abord, il faut installer fuse et sshfs sur l’ordinateur local.
sudo apt-get install fuse sshfs
Fuse est un module pour linux, il faut le charger :
modprobe fuse
Ensuite on va ajouer une petite ligne à notre /etc/fstab
:
sshfs#karchnu@karchnu.fr:/media/share/ /media/share fuse comment=sshfs,port=22,noauto,users,exec,uid=1000,gid=1000,allow_other,reconnect,transform_symlinks,BatchMode=yes 0 0
Puis on va dans /etc/fuse.conf
décommenter user_allow_others
.
Je zappe volontairement la partie où on se fait l’échange de clés SSH. Une autre solution, pour que le montage soit automatique : autofs.
Pour qu’un utilisateur puisse monter le répertoire distant sur /media/share (en local) il faut qu’il ait les droits d’écriture dessus.
]]>Vous souhaitez une copie du dépôt de votre distribution chez vous et simplement ?
Voici la solution.
J’ai développé un petit script qui s’adapte facilement aux différentes distributions : mir.tar . Ce script requiert rsync
et de 30 à 50G d’espace disque par distrib. C’est ce post qui m’a donné l’idée de faire ça. J’ai repris le code et ai ajouté quelques lignes et fait en sorte que ce soit modulable pour intégrer le support d’autant de distributions qu’on le souhaite.
Le but ? Vous téléchargez les mises à jour qu’une seule fois à partir du net puis elles se propagent en quelques secondes sur autant d’ordinateurs que vous avez. Le débit est celui de votre connexion locale ! Aux alentours de 11.4Mbps chez moi !
mir nomdeladistribution
Et éventuellement le dossier où se trouvera le dépôt. Par défaut ~/mir-nomdeladistribution
.
Ensuite, il faut mettre un lien dans votre répertoire visible sur le web (/var/www
) pour qu’on puisse télécharger les mises à jour.
ln -s ~/mir-distrib /var/www/depot
Ensuite il faut configurer votre installateur de paquet pour qu’il prenne votre miroir comme prioritaire. Pour archlinux : /etc/pacman.conf
[core]
Server = votre_site_ou_IP/depot/core/os/votrearchitecture
Il en va de même pour les autres dépôts (extra, community …).
Pour l’instant, la seule distribution disponible est Archlinux. Bientôt Debian. C’est adaptable à votre distribution facilement.
N’oubliez pas : on peut en faire une tâche cron !
Mon dépôt git.Blog d’un coupaing linuxien.
Non non, ne me remerciez pas.
]]>Pour recréer le cache (récupérer de nouveau la liste des fichier) :
sudo pacman -Syy
Pour supprimer les fichiers du cache :
sudo pacman -Scc
Pour les utilisateurs de yaourt : s/sudo pacman/yaourt/ ;)
]]>Bientôt 2 mois que le site est en ligne. Le serveur est à 42°C pour le CPU et 33 pour la CM. Je suis content d’avoir ce petit jouet avec moi… mais il fait CHAUD. Vivement la fin de l’été.
Un lolcat pour ceux qui cliquent.
Parce qu’il faut en parler, et que Korben le fait bien mieux que moi : lisez ceci. Merci.
]]>Pour avoir toujours les informations utiles sous le coude.
Simple :
yaourt -Sy arch-wiki-docs arch-wiki-docs-fr
Comme ça on a le wiki FR et EN. Les fichiers sont
file://localhost/usr/share/doc/arch-wiki/html/index.html
et
file://localhost/usr/share/doc/arch-wiki-fr/html/index.html
C’est pratique, et c’est ici que j’ai trouvé l’info.
Inconvénient : c’est supra-moche. No css style sheet.
]]>Pour mettre fin aux préjugés selon lesquels le hacker est un p’tit blanc planqué dans sa chambre avec une pizza froide et qui tente de pirater les numéros de CB enregistrés sur ibaie, voici un article présentant une étude sur la diversité dans le monde du hacking.
Voici donc une image résumant tout ça :
]]>Juste pour dire : MAME est un projet qui a pour but de faire l’émulation de tous les jeux d’arcade depuis les années 70’ ! Ça me semble sympa alors je partage la news.
]]>Pour faire un copier / coller sur xterm c’est super simple :
^END
^INSERT
Maintenant je pense que je n’utiliserai plus que xterm… ♥
]]>Démarrer son ordinateur à partir du rézo, c’est rapide et simple.
Voici comment faire.
Vérifier que votre carte accepte le wake-on-lan (Wake-on: g) :
ethtool eth0
Sinon :
ethtool -s eth0 wol g
Puis ajouter « ethtool -s eth0 wol g » au rc.local
avant la ligne « exit 0 ». 4. Récupérer l’adresse MAC de votre carte réseau (champ HWaddr) :
ifconfig eth0
Ensuite on essaie de démarrer le premier PC :
wakeonlan XX:XX:XX:XX:XX:XX
Si ça marche pas : dommage. It workz @ home.
En supplément, les différents types de wake-on-lan que vous pouvez utiliser :
p => Wake on phy activity
u => Wake on unicast messages
m => Wake on multicast messages
b => Wake on broadcast messages
a => Wake on ARP
g => Wake on MagicPacket(tm)
s => Enable SecureOn(tm) password for MagicPacket(tm)
d => Disable (wake on nothing). This option clears all
Voilà, récemment j’ai eu à modifier un ensemble de fichiers et leur ajouter une ligne. Chose vraiment simple avec Sed !
Par exemple, on souhaite ajouter une ligne au début du fichier (numéro de la ligne = 1) :
sed -i '1iCoucou' monfichier.txt
L’option “-i” est là pour écrire directement dans le fichier (monfichier.txt) sans passer par un fichier temporaire.
“1iCHAINE” => permet d’insérer en première ligne “CHAINE”
“1cCHAINE” => modifie la première ligne (la remplace par “CHAINE”)
“1aCHAINE” => ajoute après la première ligne “CHAINE” (équivalent à ‘2iCHAINE’)
On peut vouloir utiliser sed comme avec s/bla/truc/ mais en supprimant une ligne (celle contenant une chaîne de caractères, ou n’en contenant pas par exemple). Un problème que j’ai eu à résoudre récemment : supprimer les lignes vides.
sed -i '/^$/d' fichier.c
L’option d
permet de supprimer ce qu’on a trouvé (ici la ligne).
C’est simple, et pratique. Ne pas se priver.
Vous avez un OS 64 bits ? Genre ubuntu, debian … et vous avez un vilain binaire (logiciel) qui ne tourne qu’en 32 bits et que vous souhaitez quand même installer ?
Rien de plus simple, il suffit d’avoir des bibliothèques 32 bits ! Pour ubuntu -et sans doute debian aussi- :
apt-get install ia32-libs
Transposable sur les autres distrib’ (just find the package name…).
Enjoy !
Pour ne plus avoir de bip système (le speaker de la carte mère qui fait BIIIIIIP) :
echo "blacklist pcspkr" >> /etc/modprobe.d/blacklist.conf
Voilà, au prochain démarrage de la machine il n’y aura plus ce BIP qui agace tout votre entourage (voisins compris).
Pour ceux qui ne veulent pas redémarrer :
modprobe -r pcspkr
Merci qui ?
Oui, dis comme ça ça a l’air con. Mais je parle bien d’informatique là.
Si on souhaite essayer un nouveau DE (Desktop Environment) et qu’on veut voir ce que ça donne sans se déconnecter / reconnecter, on peut avoir une fenêtre dans laquelle on va mettre ce DE.
On passe aux choses sérieuses : il faut installer Xephyr (pour ubuntu, le paquet est “xserver-xephyr”). Maintenant on ouvre 2 terminaux :
Xephyr -ac -br -screen 800x600 :1
DISPLAY=:1 awesome
J’ai pris comme exemple “awesome”, bien sûr ça aurait pu être n’importe-quel autre bureau.
C’est probablement un des meilleurs documentaires jamais fait à propos du “hack”.
Je pensais regarder les 5 premières minutes puis finalement à 4h du mat’ j’ai tout regardé. Je vous le conseille fortement. Il faut conserver ceci, c’est très instructif et très bien tourné.
Ça parle de ce que c’est le logiciel libre, ce pourquoi on partage de la musique via P2P, qui sont les hackers et pourquoi ils font tomber des sites de multinationales… etc.
Tout est vulgarisé pour que tous puissent comprendre. GO !
http://www.youtube.com/watch?v=JxfGpH-cjsw&feature;=player_embedded
J’ai trouvé cette vidéo sur le site de LinuxManua et elle a été faite par… France 4 ! Oui c’est bizarre qu’une vidéo de qualité vienne de France 4 (à ce sujet, bien entendu).
Après, je pense qu’il y a quelques soucis d’un point de vue technique… “le mp3 c’est les hackers”… ouais c’est proprio les mp3 mais bon… je ne leur en veux pas trop.
N’hésitez pas à m’envoyer vos remarques ! Même si ça fait 4 ans que ce post a été publié ! RIEN À FOUTRE ! Un avis n’a pas de date de péremption (just my 2 cents).
En tapant “Karchnu” dans le moteur de recherche que tout le monde connait, j’ai 6 résultats qui apparaissent… (content)
]]>Ma chère et tendre a trouvé ceci sur le site d’écrans.fr :
Voilà ce que c’est que la neutralité. Facile à expliquer désormais à toute votre famille.
… suffit de dire “va sur karchnu.fr” par exemple ou un truc comme ça…
Bon, je viens de choper une info intéressante parmi les commentaires d’un site intéressant : un raccourcis pour faire des recherches plus rapidement avec Firefox.
Ceci m’a donné l’idée de décrire mon usage de ce navigateur web.
Ce post est un peu plus long que d’habitude. Lisez quand même. :)
Tout d’abord, après le passage de Tristan Nitot (président de Mozilla Europe) chez libé (Ecrans.fr) qui m’a rappelé une des fonctionnalités de Firefox : Firefox Sync.
Pour ceux qui ne connaissent pas : cela permet d’avoir vos marques-page, mots de passe, historique et mêmes onglets de partout !
Exemple : vous avez 3 ordinateurs (oui 3). Vous utilisez un ordinateur au boulot, un ordinateur portable pour quand vous êtes chez des amis (oui le g33k sait faire plaisir aux copains en s’invitant boire du café à l’improviste) et enfin un ordinateur fixe (genre home cinéma).
Vous naviguez sur le net, trouvez un site intéressant. Avec Firefox Sync, vous le mettez en marques-page et hop, vous l’avez sur vos autres ordinateurs !
Je l’ai essayé, je l’ai adopté. Sécurisé (ils ont nos informations chiffrées), rapide, SIMPLE et tellement pratique… Ultime : il y a la possibilité (nativement) d’avoir un serveur à la maison pour garder ses informations chez soi ! J’y pense, j’y pense…
Donc jusque-là, je vous ai parlé de FF sync et des bookmarks. Parlons “plugins” maintenant.
Les plugins !
Les seules extensions que j’utilise sont : Hide My Ass pour naviguer “protégé” (on parle de capotes? non mais ne pas être anonyme peut être dangereux pour la santé). Facile à prendre en mains, il suffit de marquer “hma URL.DU.SITE” et on est couvert par un proxy. AdBlock Plus pour ne pas avoir de publicités intempestives lors de ma navigation.
Et … c’est tout. Oui j’en utilise pas des masses… mais je vais en chercher d’autres bientôt pour les présenter ici ! La seule condition : qu’il me soit utile et simple d’utilisation sinon je l’utiliserai jamais.
Enfin, j’utilise aussi un petit nombre de raccourcis clavier :
CTRL + l (touche “elle” minuscule) => aller directement à la barre d’adresse (url).
CTRL + t => ouvrir un onglet.
CTRL + w => fermer l’onglet courant.
CTRL + q => fermer Firefox.
CTRL + b => ouvrir et fermer les marques-page.
CTRL + PAGEUP ou PAGEDOWN => navigation entre les différents onglets.
CTRL + k => barre de recherche (à droite de la barre d’adresse)
CTRL + f => faire une recherche dans la page actuelle
Des raccourcis très courants pour n’importe-quel utilisateur je vous l’accorde.
Un peu plus fin : lorsque l’on est dans la barre de recherche (CTRL + k), si on fait CTRL + HAUT ou BAS
on peut choisir le moteur de recherche (Google, Wikipedia, Amazone, Ubuntufr, i-baie …). Très rapide pour lancer une recherche…
C’est tout pour le moment… peut-être que j’ajouterai des informations sur ce post, revenez de temps en temps ! :p
En trifouillant WordPress j’ai voulu ajouter du gros “son” qui tue mais le lecteur audio que j’ai choisi (Haiku Player) ne peut lire que des fichiers mp3…
Pas grave ! Il existe ffmpeg qui est parfait pour faire de la conversion !
ffmpeg -i monfichier.ogg -ab 192k monfichier.mp3
Sauf que voilà, ça ne fonctionne pas :
Encoder (codec id 86017) not found for output stream #0.0
La solution que j’ai trouvé (pas forcément la meilleure donc ;) ) :
apt-get install ffmpeg libavcodec-extra-52
Pour information, Haiku Player fonctionne très bien sur gnu/linux (pub innocente pour the best OS ever).
Wordpress vous demande des informations pour la connexion à votre serveur FTP pour pouvoir faire des mises à jour : c’est pénible !
“ZOMFG WTF ?” me direz vous.
Voici une solution simple pour qu’il vous laisse tranquille.
Il suffit simplement d’aller dans votre répertoire où est installé wordpress.
cd /var/www/mywordpress
Puis donner un accès total aux répertoires à l’indien :
chown -R www-data:root .
Et voilà !
Maintenant l’installation de plugins, thèmes et autres updates se fait tout seul !
]]>Bon, je viens de me prendre un ndd en .fr et je me suis renseigné pour savoir comment récupérer mes IP.
Alors, en local c’est assez simple pour moi étant donné que j’ai tout mis en dur. Mais malgré tout voici une commande simple pour connaître son IP locale :
hostname -I
Pour l’IP publique :
GET whatismyip.org
Il y a évidemment tout un tas de manières de récupérer ces 2 informations, mais là ce sont des manières (très) simples et qui marchent !
Enjoy !
]]>Voilà ! Il faut bien profiter des 16go que vous avez tous dans vos ultra-portables ! Alors ce qu’on va faire c’est monter une partie de notre mémoire vive dans un répertoire (genre /media/fast
).
Mais pourquoi faire ça ? Tout simplement parce que la mémoire vive est sacrément plus rapide et plus réactive que le disque dur ! Alors, compilation ? Cache de Firefox ? Sécuriser sa connexion (priv8 jok wiz Albanel) ?
Je vous laisse le soin de trouver VOTRE utilité à cela. :)
Ça ne prend que 2 minutes et c’est pratique.
Faire la manip’ s’avère d’une facilité déconcertante sous gnu/linux. Tout d’abord on se crée notre répertoire :
mkdir -p /media/fast
Puis il suffit d’utiliser l’utilitaire “mount
” comme suit :
mount -t tmpfs -o size=2G tmpfs /media/fast
Par contre n’oubliez pas qu’en cas de coupure de courant, tout ce qu’il y a dans ce répertoire est perdu. :p
Autre chose, on peut facilement ajouter une ligne à notre /etc/fstab
pour l’ajouter au démarrage :
tmpfs /media/fast tmpfs size=2G,rw,mode=1777 0 0
Enjoy !
]]>Actuellement je lis un livre de Jean-François Bouchaudy (le nom est dans le titre !) et il traite des bases de l’administration système.
Vraiment intéressant et abordable par tous. Enfin, pour ceux qui savent au moins ce qu’est un terminal.
Il est rédigé de la manière suivante :
un récapitulatif des commandes qui vont être abordées l’objectif du chapitre contenu du chapitre
Puis il y a dans le chapitre 2 parties : premièrement la théorie qui permet de connaître le fonctionnement des outils que l’on va utiliser, puis dans la seconde partie il y a “l’atelier” qui permet de mettre en pratique ces connaissances au travers d’un ensemble de commandes utiles.
Je conseille ce livre à ceux qui chercheraient en savoir un peu plus sur gnu/linux sans se fatiguer. Un chapitre se termine assez vite, on fait vite le tour du livre et on en redemande !
Ça tombe bien, j’ai les trois autres tomes à la maison…
L’auteur recommande 3 à 4 jours à temps plein. Autant se prendre deux bonne semaines en feuilletant le bouquin une petite heure chaque soir.
Pour chipoter : il n’y a que trop rarement écrit le mot “Gnu” dans le bouquin.
Coucou !
Je ne viens pas de perdre 1h à comprendre d’où venait le problème avec mon .tk et je ne pète pas un plomb.
[/fullzen]
Bon ok ça m’a bien gonflé : aujourd’hui j’ai dit haut et fort (dans ma tête) “FUCK network-manager, GO IP FIXE”. D’un coup d’un seul j’ai installé une p’tite IP fixe pour mon pc perso et j’ai supprimé network-manager.
Un problème : je n’arrive plus à accéder à mon site en .tk. WTF ?
J’ai tout d’abord vérifier que ça ne venait pas du service “my.dot.tk” et… non, ils me disent que tout est en règle et quand je regarde mon quota pour le mois il est au dessus de toutes attentes…
Hola ! Je vois que des DNS refusent le .tk parce que des vilains pirates les utilisent… et aillant mis les DNS d’opendns et de google… je me suis dit que ça venait de là !
Bah non. Quand je fais un
dig karchnu.tk
je m’aperçois que j’ai un “SERVFAIL” … intéressant tout ça…
Tant pis, j’ai du rusé :
vim /etc/hosts
et je mets :
192.168.yyy.xxx karchnu.tk
et hop ça marche !
En espérant que mon site soit disponible en dehors de chez moi… il est possible que non, mais au moins j’y ai accès et ça me suffit pour le moment ! Mais… zut quoi :’(
EDIT: je viens de faire un test via “dig” :
dig @8.8.8.8 A karchnu.tk
et je ne vois pas de réponse correcte… avec l’IP d’openDNS (208.67.222.222) je reçois une mauvaise IP… sans doute une IP qui me redirige vers ma vraie IP ? En tous cas ça ne fonctionne pas.
EDIT2: mon .tk a remarché durant la journée, ce soir il replante… mais entre-temps je me suis payé un .fr. Fuck yeah.
Récemment j’ai du installer une imprimante Canon MP499 chez mes parents (ils ont un Xubuntu 11.04 tout frais sur leurs 2 postes).
Bon, l’installation automatique de l’imprimante… marche pas. Tant pis, je vais sur le net au petit bonheur la chance et je tombe nez à nez avec cette page.
L’installation se fait simplement en lançant l’exécutable install.sh
.
J’ai regardé, apparemment leurs pilotes sont sous licence GPL… (l) Canon (l).
Cependant, je n’ai pas réussi à installer l’imprimante en wifi ni le scanner (pour le scanner, d’autres pilotes sont dispo sur le site). Je n’avais que peu de temps… tant pis !
Pour arrêter de se taper des é
à longueur de journée à écrire du HTML pur souche, on peut placer cette ligne entre les balises <head></head>
:
<meta content="text/html; charset=UTF-8" http-equiv="content-type"></meta>
C’est quand même mieux.
PS : écrire du HTML dans wordpress peut s’avérer être une tâche ardue, pour cela il existe le plugin “code markup” qui est très pratique !
]]>Voici une commande que j’utilise assez souvent pour sauvegarder ma musique téléchargée illégalement : rsync.
Alors voici LA commande que j’utilise :
rsync -avz user@address:rep_origine user@address:rep_destination
Pour faire une copie parfaite d’une source à un “miroir” et donc supprimer ce qui a été supprimé dans le répertoire source, il faut ajouter l’option --delete
. Pratique… mais dangereux ! Faites attention.
Je n’explique pas les différentes options RTFM , j’expliquerai plus tard (il se fait tard).
Les templates, c’est quoi ?
C’est permettre à un utilisateur de pouvoir taper “vim mon_nouveau_programme.c” et d’avoir par défaut un ensemble de lignes déjà pré-inscrites dans le fichier.
C’est simple. Jetez-vous sur cet article.
Pour faire ça, tout d’abord, il faudrait avoir un nouveau répertoire dans lequel on va stocker l’ensemble des fichiers dits “template”.
mkdir -p ~/.vim/skel/
Ensuite, on va éditer un fichier de template :
vim ~/.vim/skel/tmpl.c
Une fois que le fichier est édité, il ne manque plus qu’à modifier le fichier “~/.vimrc” pour lui insérer cette ligne :
autocmd! BufNewFile * silent! 0r ~/.vim/skel/tmpl.%:e
Le fichier “~/.vimrc” ne sera plus modifié par la suite, même si on souhaite ajouter d’autres modèles (autres fichiers “tmpl” avec d’autres extensions).
À partir de maintenant, à chaque fois qu’on va éditer un fichier avec pour extension “.c” vim va charger notre “~/.vim/skel/tmpl.c” !
Enjoy !
Encore un tips !
Pour avoir une IP fixe en local il suffit de modifier le fichier “/etc/network/interfaces” et mettre ça :
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
iface eth0 inet static
address 192.168.0.100 # l'adresse ip souhaitée de votre pc
netmask 255.255.255.0 # le masque de sous-réseau
gateway 192.168.0.1 # la passerelle (votre box)
auto eth0
Ensuite il ne manque plus qu’à redémarrer votre connexion :
/etc/init.d/networking restart
J’ai eu des soucis avec network-manager, ne m’en servant PLUS du fait que je me donne une IP fixe sur mon réseau local, je l’ai supprimé :
apt-get remove network-manager
Je n’ai pas supprimé mes fichiers de configuration (option --purge
) car dans le doute…
Voilà !
]]>Mon network-manager a fait des siennes !
J’avais un soucis avec ma connexion via mon câble ethernet, network-manager m’affichait “device not managed” et je ne pouvais donc pas me connecter. La solution est simple :
sudo vim /etc/NetworkManager/NetworkManager.conf
Il faut modifier la ligne en dessous de [ifupdown] “managed=false” par “managed=true”. Ensuite un redémarrage de network-manager et hop :
stop network-manager
start network-manager
Le tour est joué !
]]>Il y a quelques soucis avec les cartes Broadcom et la nouvelle version d’Ubuntu 11.04. Dans l’applet NetworkManager nm-applet on ne voit plus le wifi. La seule option qu’on a c’est d’activer ou de désactiver le réseau.
J’ai trouvé un ensemble de réponses à ce propos.
http://askubuntu.com/questions/38327/broadcom-bcm4311-wireless-not-working
Pour faire court : supprimer “bcmwl-kernel-source”.
sudo apt-get autoremove bcmwl-kernel-source
Puis on va installer “firmware-b43-installer” et “b43-fwcutter” (pour le second, apparemment ça marche sans).
sudo apt-get install firmware-b43-installer b43-fwcutter
Ensuite un p’tit reboot et c’est bon. Si ça ne fonctionne pas :
sudo rfkill unblock wifi
Puis un reboot.
Cette solution a fonctionné pour moi (Dell inspiron 6400 plutôt ancien de mes parents :) ).
]]>Actuellement je lis 2 livres sur le langage C.
Le premier : “Développement système sous Linux” de Christophe Blaess.
Très intéressant et assez complet, il est bien écrit et permet de se plonger dans le langage C en respectant les standards POSIX et ANSI. Il reprend les bases de la programmation C et va loin dans les explications.
Le second : “C en action” de Yves Mettier.
Ce livre est le parfait complément du premier, il permet de voir des cas pratiques (xml, compression etc.). Très pratique lorsque vous avez besoin d’effectuer une tâche rapidement et que vous souhaitez un exemple expliqué.
Pour bien comprendre le tout, il vous faudra cependant du temps !
Petit conseil : si vous souhaitez apprendre le langage C (la base et un peu beaucoup plus) je conseille de lire le premier livre. Il permet de comprendre beaucoup de choses concernant le fonctionnement d’un système d’exploitation. Le second lui, permet de se concentrer sur un problème concret. Il n’a pas pour but de faire de vous une bête de programmation C.
Bonne lecture !
PS : les deux auteurs sont des libristes reconnus. Ceci est un très bon point.
Et le rouge c’est moche.
En premier lieu j’ai envie de dire “tant pis”.
Mais après tout, je ne fais pas ce blog QUE pour moi, si d’autres s’y sentent bien…
Alors je vous propose de m’envoyer par e-mail d’autres images.
Merci à vous.
MPD est un dæmon qui tourne sur l’ordinateur et permet de manipuler une bibliothèque de son. Il ne consomme rien, permet de changer la musique qui tourne à distance et on peut facilement écrire des scripts qui l’utilisent via “mpc”. Depuis que je connais ce logiciel je n’écoute ma musique qu’avec lui.
Le client que j’utilise est ncmcpp.
Pour la configuration, voir là. Peut-être que je ferai un p’tit tutoriel perso mais la doc sur ubuntu-fr est plutôt bien faite.
]]>Une question qui pourrait se poser : pourquoi utiliser une couleur de fond de site sombre ?
Tout simplement parce que mon écran d’ordinateur est une télé 32" et que ça me pète violemment les yeux quand il n’y a que du blanc qui s’affiche.
Clair, net et précis.
]]>Pour avoir des man-pages un peu moins moches, “most” ! Ce logiciel permet d’avoir un peu de couleur dans les pages de manuel sur Gnu.
Démarche à suivre pour y voir clair dans les pages de manuel :
apt-get install most
export MANPAGER="/usr/bin/most -s"
Au cas où vous ne voudriez plus de ceci :
unset MANPAGER
aptitude remove most --purge
Simple et efficace. Je trouve cela assez agréable.