JaguarWan a écrit 331 commentaires

L'autre jour quand mon alim' a explosé j'ai transféré mon installation Slackare de mon P4 i865 + nvidia 5700 sur un vieux Dell PowerEdge 1300 que j'avais sous la main (bi p3 550 + ATI Rage IIc) et honnêtement, j'ai juste eu à faire un gros cp -a de mes disques durs puis modifier le xorg.conf et le fstab.

Ah, et recompiler un noyau aussi (normal).

Donc à part xorg.conf, fstab et éventuellement le /etc/modules.conf, je ne vois pas trop ce qui peut être si pénible avec /etc lors d'un changement de machine ?

Je trouve qu'il est comparativement bien plus simple de changer une installation de machine avec GNU/Linux que Windows par exemple (ghoster une machine et restaurer l'image sur une autre ça le perturbe pas mal).

En une heure et demie, le temps de partitionner le raid, copier toutes les données, recompiler un noyau, et éditer la conf de base c'était prêt. Et j'avais une copie carbone de mon système d'origine, complètement opérationnelle (sauf la Rage IIc qui voulait pas passer en 1280x1024 ;) )

J'ai d'ailleurs été assez impressionné par la réactivité du système, quasi identique à celle que j'avais sur mon P4 alors que je n'ai absolument pas tweaké la configuration (cp -a power). Chapeau à Slackware et KDE.

Mmmh, permet moi de mettre en doute ton affirmation (en tout cas en ce qui concerne KDE).

Quand ma bécane principale est tombée en panne j'ai migré momentanément mon système sur un vieux Dell bi-PIII 500 mhz / 512 megs de ram, avec en guise de carte vidéo une vieille ATI Rage IIc incapable de monter jusqu'en 1280x1024 faute de VRAM, et KDE 3.4.2 tournait tout à fait fluidement sans même toucher au swap.

Étant donné que KDE 3.5 est un plus véloce et économe en mémoire que le 3.4, on devrait pouvoir faire tourner aisément ce merveilleux environnement de bureau sur une bécane plus rustique.

Quand au /usr et /var de 4 gigs, c'est n'importe quoi: une installation complète de KDE fait 652 megs sur ma slack, et mon /var/tmp/kdecache (je suppose que c'est ce à quoi tu faisait allusion) 118 megs (j'ai autorisé le cache du brouteur à 64 megs de temporaires)... soit moins du quart de tes indications.

Donc bon, tout est relatif: KDE est effectivement beaucoup plus lourd que twm, mais faut pas exagérer, il tourne plus que décemment sur des machines d'il y a ~10 ans.

A chaque fois qu'on tue un chaton à coups de pelle, Dieu tue un chaton !

----->[]

Je suis chez Wanadoo (campagne profonde oblige), et mon Konqui affiche fièrement:

An error occurred while loading http://www.site-inexistant.com:
Unknown host www.site-inexistant.com

J'utilise les DNS suivants:
nameserver 193.252.19.3
nameserver 193.252.19.4

Apparemment cette "fonctionnalité" n'est donc heureusement pas encore implémentée sur tous leurs DNS.

M'enfin sur le screenshot c'est un Firefox win32 qu'on voit, ça ne pourrait pas être la conséquence de l'installation d'un kit de connection ou autre abomination ?

Ta carte graphique a la chance d'être entièrement supportée par les drivers libres !

Donc si tu as la possibilité de passer à Xorg au lieu de l'antédiluvien XFree86, je te conseille d'utiliser les drivers libres :)

Il est même possible que le vieux XFree gère ta carte nativement, tu peux essayer de voir ce qui se passe en mettant Load "dri" dans la section Module du fichier de conf et driver "radeon" dans la section Device...

Tu as essayé d'utiliser les sémaphores/mémoires partagées SystemV ?

semget(2), semctl(2) (sémaphores), shmget(2), shmctl(2), shmat(2) et shmdt(2) pourraient t'intéresser.

D'autre part, si tu as une segfault vérifie que tu n'as pas déclenché un buffer overflow: un autre post relève un gros trou (char ** filé au scanf + pas de limite de saisie) dans ton code de saisie utilisateur, et dans ton source tu fais à plusieurs reprise des au lieu de sympathiques memcpy().

Je n'ai pas regardé en détail mais vérifie aussi tes manipulations de pointeur, Linux n'aime pas qu'on se balade en dehors d'une map.

Dans tous les cas, en cas de segfault étranges, valgrind et gdb sont tes meilleurs amis :)

char n[20], p[20];

printf("Nom:"); fgets(n, sizeof(n) * sizeof(char), stdin);
printf("Prenom:"); fgets(p, sizeof(p) * sizeof(char), stdin);

c'est plus secure quand même.

P.S.: fflush(stdin) a un comportement indéfini, ça n'est autorisé que sur stdout.

Merci pour ton retour :)

J'ai aidé un ami à installer une slack sur son portable, qui dispose d'une ATI IGP 320 U1 (r300), et il a une accélération 3d fort raisonnable avec le driver libre, ce qui me laissait espérer de bonnes choses.

Ce que j'ai vu sur le bugzilla me paraît ambigü, d'un côté certains jouent à UT2003 avec le driver libre (!), d'autres ont des hardlocks dès qu'ils lancent X.

De toute façon qui s'attend encore à avoir de l'information de qualité au journal de vingt heures ?

En attendant, si la cause du peer to peer vous tient à coeur, le projet aMule a besoin de dons pour acheter un nouveau serveur. Leur hébergeur les a mis dehors car le projet prenait trop de ressources.

http://www.amule.org/

Si tu n'as pas envie d'installer KDE 3.5, tu peux utiliser tout simplement un fichier /etc/hosts pour bloquer la publicité. Simple et radical, marche avec tous les navigateurs ;)

Tu peux en trouver un très bien fourni ici:

http://someonewhocares.org/hosts/

Il suffit de l'ajouter à ton /etc/hosts existant pour que toute cette pollution visuelle disparaisse définitivement de ton écran :)

En fait je te suggère de mettre ta box en dhcp, comme ça tu n'as pas à te soucier de l'établissement de la connection. Sur certains de ces appareils ils appellent ça "Activer la DMZ".

Ensuite pour être connecté, il suffit de mettre ton interface réseau en dhcp, sous Slack c'est faisable trivialement en mettant dans /etc/rc.d/rc.inet1.conf:

# Config information for eth0:
IPADDR[0]=""
NETMASK[0]=""
USE_DHCP[0]="yes"
DHCP_HOSTNAME[0]=""
DHCP_KEEPRESOLV[0]="yes"

(en admettant que ton truc soit sur eth0)

L'option DHCP_KEEPRESOLV permet de spécifier des dns dans /etc/resolv.conf et qu'ils ne soient pas écrasés par dhcpcd (le daemon dhcp-client).

Normalement à ce stade tu auras le net.

Ensuite si tu veux partager ta connection ou avoir un firewall, il faut utiliser iptables... je te propose le script suivant:

http://mammouth.tuxfamily.org/slackware/rc.firewall

Il faut le mettre dans /etc/rc.d/rc.firewall, il est dérivé de celui proposé par Olivier ALLARD-JACQUIN (merci à lui) disponible ici (avec documentation exemplaire) : http://olivieraj.free.fr/fr/linux/information/firewall/

Il se configure facilement et marche très bien :)

Pour le relancer à chaque reconnection, le mieux c'est de demander à dhcpcd de le relancer à chaque fois.

Les scripts de /etc/dhcpc/ de base de la Slack 10.2 ne marchent pas bien, je te propose les miens:

http://mammouth.tuxfamily.org/slackware/dhcpcd.exe
http://mammouth.tuxfamily.org/slackware/dhcpcd-eth0.exe

A adapter pour ton interface réseau (normalement, juste le nom à changer pour dhcpcd-eth0.exe ;) )

Voilà voilà, happy slackin' :)

Ta méthode de compilation me paraît étrange... Pour compiler un noyau 2.6, normalement on n'a plus à faire make bzImage et compagnie, mais tout simplement make, make install et make modules_install.

D'autre part, dans les dernières version du 2.6, make install met directement, par défaut, System.map et vmlinuz dans /boot (au lieu de / dans les versions précédentes).

Donc en gros, pour compiler un noyau sous Slack, c'est pas compliqué: tu prend la version qui t'intéresse sur kernel.org, tu appliques éventuellement les patches de ton choix, tu le configure aux petits oignons pour ta machine, et un make && make install && make modules_install plus tard c'est prêt.

De base c'est lilo le bootloader de la slack, je connais pas bien grub donc je peux pas trop t'aider, mais tu as essayé avec lilo ?

Pareil, normalement il n'y a pas besoin d'un initrd, j'en utilise un seulement pour les images du bootsplash...

Rigole, mais sur certains vieux coucous (PDP-10 entre autre) tu as des words de 36 bits et donc des "octets" de 9 bits en C :þ

http://en.wikipedia.org/wiki/36-bit_word_length

CHAR_BIT dans limits.h ça n'est pas là pour rien ;)

C'est bon, je sors :D

[Welcome to Jurassic Park]
||                                   ||
||                                   ||
                   /\
_____________|

Mouais, traduction tendancieuse... Je ne suis pas une bête en anglais, mais voilà quelque chose de plus proche du sens original (c'était pas difficile :) ):

Ce projet, bien que majoritairement bien accueilli, a reçu quelques critiques de la communauté open source. La base de donnée de bugs devrait aider à rendre les logiciels open source plus sûrs, mais d'une manière détournée, a déclaré Ben Laurie, un directeur de la Fondation Apache qui est également engagé dans [le projet] OpenSSL. Une méthode plus directe serait de fournir des outils d'analyse de code aux développeurs open-source eux même, affirme-t-il.

"Il est regrettable que le Department of Homeland Security ait décidé une fois de plus de s'assurer que des entreprises privées profitent de ce financement, tandis que les développeurs open-source doivent mendier les restes", a-t-il déclaré. "Pourquoi le DHS pense-t-il qu'il est approprié de payer pour la découverte de bugs, mais n'a pas prévu de fonds pour rétribuer leur correction ?"

Le Department of Homeland Security n'a pas répondu à ces critiques pour le moment.

"I followed Loveless up to his hotel room to get a first hand example of how this attack would work. I set up an ad hoc wireless network connection on my Windows XP laptop named "hackme." Within a few seconds of hitting "Ok," to create the network, my laptop was assigned a 169.254.x.x address. A few seconds later, Loveless could see my computer sending out a beacon saying it was ready to accept connections from other computers that might also have the "hackme" network pre-configured on their machines. Loveless then created an ad hoc network with the same name, and told his computer to go ahead and connect to "hackme." Viola! [(oui, le journaliste semble apprécier les instruments à corde)] His machine was assigned a different 169.254.x.x address and we both verified that we could send data packets back forth to each other's computer."

La description du "hack" me semble être le fonctionnement normal d'un réseau ad-hoc, non ? Si on configure sa machine comme point d'accès ad-hoc même pas crypté, 'faut pas s'étonner que d'autres machines puissent s'y connecter.

Dans tous les cas, si la machine derrière est bien tenue, c'est pas plus dangereux que d'être connecté au net (où, je le rappelle, n'importe qui peut nous balancer des packets ! ça fait peur, hein ?).

En plus, il est tout à fait possible de configurer une machine sous n'importe quel OS gérant un minimum le WiFi pour avoir un comportement similaire.

Bref, ça me semble être du Microsoft-bashing primaire cette affaire :)

Tu as essayé de faire un beau package avec le slackbuild généreusement fourni par Patrick ?

http://www.slackware.at/data/slackware-current/source/l/glib(...)

Logiquement, tu as juste à modifier le numéro de version de la library dans le script, et hop un sh glib2.SlackBuild devrait te faire un package tout propre :)

Les slackbuilds, c'est bon, mangez-en :]

La faille marchait sous Wine, qui a ré-implémenté le format from scratch d'après la spécification. Donc, techniquement, on pourrait s'amuser à infecter son dossier .wine/drive_c sous GNU/Linux à grand coups de WMF vicieux ;)

Le fait que ça marche sous Wine me semble également rendre la thèse de la Cabale un tantinet moins probable que la thèse du design hasardeux, non ? :)

En tout cas, ça c'est de la vraie bug-for-bug compatibility...

J'ai crafté des slackbuilds avec amour, et ça marche au poil :)

Tu peux pomper packages tout f(r)ais (pour Slack-current) et slackbuilds là:

http://mammouth.tuxfamily.org/slackware/wormux-slackbuild/

Slackware über alles quoi :)

OK, j'ai implémenté ça en utilisant la doc sur IEEE754 et ça marche au poil :)

Apparemment ça marchait sur 32 bits par coïncidence, le single precision étant bien aligné... mais c'est plus valable en 64 bits.

Merci beaucoup pour ton aide :)

> Pour en revenir à ton application, fonctionnellement, pourquoi as-tu besoin
> de faire de tels traitements ? Ton appli transfère des informations entre
> différentes machines ? Tu veux parser des fichiers binaires ?

En fait c'est pour mon serveur idiot: je compte utiliser le sscanf modifié pour lire le buffer du socket confortablement, d'où nécessité de gérer les formats binaires de base :)

Pour 'daemonizer' le processus courant, j'utilise ce bout de code (le boolean en paramètre sert à indiquer si on doit faire un double fork ou pas -- en pratique, si tu le lances pas avec init faut le mettre à true):

------------------------------8<--------------------------------

static void daemonize(int dofork)
{
/** @brief This daemonizes the current process */

pid_t pid;
struct rlimit limit;

/* Set to background */
if (dofork || getppid() != 1)
{
pid = fork();

switch(pid)
{
case -1: /* Error */
perror(ERR(daemonize, fork)); exit(1);
break;
case 0: /* Success */
break;
default: /* Kill the father */
exit(0);
}

/* Run the processus in a new session */
setpgid(0, 0);

pid = fork();

switch(pid)
{
case -1: /* Error */
perror(ERR(daemonize, fork)); exit(1);
break;
case 0: /* Success */
break;
default: /* Kill the father */
exit(0);
}

/* Ignore terminal signals */
if (signal(SIGTTIN, SIG_IGN) == SIG_ERR)
{
perror(ERR(daemonize, signal)); exit(1);
}
if (signal(SIGTTOU, SIG_IGN) == SIG_ERR)
{
perror(ERR(daemonize, signal)); exit(1);
}
if (signal(SIGTSTP, SIG_IGN) == SIG_ERR)
{
perror(ERR(daemonize, signal)); exit(1);
}
if (signal(SIGCHLD, SIG_IGN) == SIG_ERR)
{
perror(ERR(daemonize, signal)); exit(1);
}
}

/* Change directory to root */
if (chdir("/") != 0) { perror(ERR(daemonize, chdir)); exit(1); }

/* Get the maximum file descriptor */
if(getrlimit(RLIMIT_NOFILE, & limit) == -1)
{
perror(ERR(daemonize, getrlimit)); exit(1);
}

/* Close all the file descriptors */
while (limit.rlim_cur --) { close(limit.rlim_cur); }
}

------------------------------8<--------------------------------

Sinon, pour ta boucle de lecture de fichier, tu pourrais utiliser fread/fwrite, ou mapper le fichier en mémoire, ou encore (dans ton premier post tu compte utiliser un socket) utiliser un socket, et la super fonction sendfile() :)

Exemples basiques:

avec fread/frwrite, ça donne ça:

------------------------------8<--------------------------------

unsigned char buffer[BUFSIZ];
for ( ;; ) {
    fread(buffer, sizeof(char), sizeof(buffer), in);
if (! feof)
        fwrite(buffer, sizeof(char), sizeof(buffer), fp);
    else
        break;
}

------------------------------8<--------------------------------

mais c'est un euphémisme de dire que c'est pas optimal :)

exemple naïf avec mmap():

------------------------------8<--------------------------------

unsigned char *map = NULL;
int in = 0;
int lp = 0;
struct stat infos;
size_t taille_fichier = 0;

if ( (in = open(ton_fichier, O_RDONLY)) == -1) {
    perror(ERR(lecture, open)); abort(); /* gestion d'erreur basique :] */
}

if ( (lp = open(imprimante, O_WRONLY)) == -1) {
perror(ERR(lecture, open)); abort(); /* gestion d'erreur basique :] */
}

/* récupère la taille du fichier à balancer */
if (fstat(in, & infos) == -1)
    perror(ERR(lecture, fstat));
else
    /* on récupère juste la taille, mais on pourrait vérifier
     * que c'est bien un fichier régulier, toussa...
     */
    taille_fichier = infos.st_size;

/* mappe le fichier en mémoire (gros tableau) */
if ( (map = mmap(NULL, taille_fichier, PROT_READ, MAP_PRIVATE, in, 0) == MAP_FAILED) {
    perror(ERR(lecture, mmap)); abort();
}

/* oh le gros write de bourrin :) */
write(fd, map, taille_fichier);

------------------------------8<--------------------------------

Et le must, le gros sendfile() de sauvage, ultra pas portable mais si bourrin :)

------------------------------8<--------------------------------

[Coller ici le même code que pour mmap, mais sans ouvrir lp]

au lieu d'appeler mmap(), et en supposant que tu as un socket connecté à ton imprimante nommé 'bull':

ssize_t ret = 0;
if ( (ret = sendfile(bull, in, NULL, taille_fichier)) == -1)
    perror(ERR(lecture, sendfile));
else
    printf("youpi, sendfile a envoyé %z bytes dans les tuyaux\n", ret);

------------------------------8<--------------------------------

Et là, enjoy, c'est le noyau qui se tape tout le boulot, et en zero-copy s'il vous plaît :)

* la macro ERR() qui apparait un peu partout c'est un truc maison pour afficher la ligne du code qui foire:

#define STRINGIFY(x) #x
#define STR(x) STRINGIFY(x)
#define ERR(c, f) #c "()::" #f "() @ " __FILE__ ":" STR(__LINE__)

Voilà voilà :)

Merci pour ce commentaire éclairé (dommage qu'on ne puisse pas plusser plusieurs fois), j'ai corrigé tout ça :)

Par contre le problème avec les floats reste entier... Voilà ce qui se passe quand je fais:


printf("float, system endianness : %f (0x%x)\n", f, (int) f);
memcpy(float_buffer, (char *) & f, sizeof(f));
f = 0;
r = snscanf(float_buffer, sizeof(long_buffer), "%bf", & f);
printf("returns %i, i = %f (0x%x)\n", r, f, (int) f);


Sur ma Slack x86, le programme de test donne ça :
float, system endianness : 1337.123413 (0x539)
returns 4, i = 4079200000.000000 (0x80000000)

Sur Mac OS X, PearPC, ça donne:
float, system endianness : 1337.123413 (0x539)
returns 4, i = 1151804416.000000 (0x44a72400)

Voilà ce qui se passe dans snscanf pour les floats binaires:

if ((flags & SUPPRESS) == 0) {
double res; /* d'origine */

if (flags & BINARY) {
res = _fetch_float(b, width, flags);
b += width; bufsize -= width;
} else {
*p = '\0';
res = strtod(buf, (char **) NULL);
}

if (flags & LONGDBL)
*va_arg(ap, long double *) = res;
else if (flags & LONG)
*va_arg(ap, double *) = res;
else
*va_arg(ap, float *) = res;
nassigned++;
}


Et la fonction de conversion, clone de celle utilisée pour les int:

static long double _fetch_float(const u_char *b, size_t w, int flags)
{
long double ret = 1;
int sys_endian = 0; /* 0 == big endian, little endian otherwise */

if (*(char *) & ret == 1) sys_endian = 1;

if (flags & BIG) sys_endian = 0; else if (flags & LITTLE) sys_endian = 1;

if (flags & TRUNK) {
if (
(sys_endian == 1 && (flags & HIBYTES)) ||
(sys_endian == 0 && (flags & LOBYTES))
) {
/* should begin from the MSB */
if (flags & LONGDBL) b += sizeof(long double);
else if (flags & LONG) b += sizeof(double);
else b += sizeof(float);
b -= w;
}
}

ret = 0;

/* fetch bytes, storing them using the given endianness */
if (sys_endian) {
while (w --) ret += ((u_quad_t) b[w]) << (w * CHAR_BIT);
} else {
size_t i = 0;
while (w --) ret += ((u_quad_t) b[w]) << (i ++ * CHAR_BIT);
}

return ret;
}


Mais le plus étrange, c'est que le code suivant marche:
r = snscanf(float_buffer, sizeof(long_buffer), "%bi", & f);
Donc en fait en utilisant le code path des entiers, ça passe même sous Mac (mais bon ça marche que sur les archis où sizeof(int) == sizeof(float)).

Alors, peut être que c'est les shifts qui passent pas, je vais essayer avec une union, mais bon, ça me trouble que _fetch_int() marche et pas ça :)

J'ai mis à jour le source sur http://mammouth.tuxfamily.org/vfscanf.c si tu souhaites voir la chose en intégralité.

Oui, Kiten est vraiment excellent, surtout la recherche de kanjis par radicaux et tout qui est vraiment pratique :D

Le comble c'est que je l'avais trouvé par hasard dans le menu 'Edutainment' de KDE (de toute façon dans KDE y a forcément une application inclue qui fait ce dont on a besoin :þ ).

D'ailleurs pour l'instant c'est surtout pour utiliser Kiten que j'ai besoin de l'IM, vu que j'ai un niveau trop pitoyable pour glander sur des chans japonais ou ce genre de chose ^_^'

Il faut toujours patcher QT pour utiliser SCIM/UIM ? En fait je suis toujours avec kinput2/Canna pour le simple fait que ça marche dans toutes les applications X11 indépendamment du toolkit graphique.

A part la gestion de plusieurs langues, UIM/Anthy apporte quoi de plus ?

Mon souhait ce serait une IM qui ferait un truc proche d'intellisense® pour la conversion, genre on commence à taper watashi et *plop* y a 私 qui apparaît :)

Sinon, un truc amusant avec kinput2: quand on tape maru ou hoshi, on peut faire des ronds et des étoiles: ● ★ (j'ai pas essayé pour d'autres figures) :]

Certain, c'est une des nombreuses applications de la législation actuelle sur la copie privée, et c'est même pour ça qu'on paye une redevance sur les médias vierges...

[mode IANAL on]
Si je prend un CD à la médiathèque, que je le rippe en FLAC sur mon disque dur, j'ai bien une copie privée parfaitement légale sans posséder l'original.

Ce qui est illégal, c'est de mettre ensuite mes fichiers FLAC en ligne disponible au tout venant, car je ne possède pas les droits de redistribution de l'oeuvre.

Le problème de "télécharger comme un sagouin", c'est uniquement si les fichiers ont été mis en ligne sans l'autorisation de l'ayant droit: si demain Maiden décide de mettre leur discographie en libre téléchargement/redistribution, je ne vois pas en quoi ce serait plus Mal® de la pomper, voire de la redistribuer, que de le faire avec un package de logiciel libre.
[mode IANAL off]

Ce qui me gène le plus avec toutes ces fourberies de contrôle, c'est que le contenu risque fortement de ne plus être lisible/utilisable dans quelques années.

Par exemple, j'ai acheté le jeu Half Life en 1999 (et pourtant j'étais au collège et sous Windows cracké à l'époque, et je piratais comme un sagouin -- message subliminal, les bons produits se vendent tout seul), il y a bientôt sept ans, et bien je peux encore y jouer sans problème avec Wine/cedega et le CD original. J'ai aussi acheté Half Life 2 l'année dernière, avec cet espèce de gros DRM qu'est Steam.

Et bien, Half Life 2, je suis pas sûr de pouvoir y rejouer dans sept ans: les serveurs d'authentification Steam seront ils encore actifs ? Déjà, maintenant que je suis retourné au dialup, je ne peux plus y jouer vu que Steam (en plus du très long décryptage en ligne) m'impose le téléchargement d'un patch monstrueusement obèse. Ironie, je pourrais probablement y jouer tranquillement avec un crack pompé sur la mule, mais j'ai laissé tombé, dégoûté par tant de mépris pour le client.

Donc, vivement que tout le contenu vidéo/audio/ludique ne soit plus disponible qu'en pay per view avec du bon DRM, comme ça ces sales pauvres d'étudiants qui copient les CDs de la bibliothèque passeront à la caisse comme tout le monde; les vrais artistes comme Laurie seront enfin rémunérés à leur juste valeur; et dix ans après on ne pourra plus utiliser nos données.