Krunch a écrit 3811 commentaires

C'est ça que tu cherches ? https://abc.xyz/investor/board-and-governance/bylaws/

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je la refais sans le pronom ambigu.

Si tu fais référence à /etc/passwd, ce fichier ne contient plus de hash de mot de passe depuis environ 40 ans. Les utilisateurs normaux n'ont pas accès aux hashes.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je sais pas sur quelle distribution tu trouves un /etc/password. Si tu fais référence à /etc/passwd, ce fichier ne contient plus de hash de mot de passe depuis environ 40 ans et les utilisateurs normaux n'y ont pas accès.

stocker dans un TPM (donc pas dans le binaire). Là oui t'es sécure :)

Ça dépend de ta définition de « sécure » : https://en.wikipedia.org/wiki/Trusted_Platform_Module#Attacks

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Celui qui veut vraiment bidouiller, s'il a accès au matériel de toute façon il finira par y arriver. Si le matériel lui appartient, lui mettre des bâtons dans les roues ne me semble pas une bonne idée. Si le matériel ne lui appartient pas, c'est plus un problème entre l'opérateur et le propriétaire et c'est pas avec du logiciel que tu vas le résoudre.

Dans tous les cas, ça s'apparente à du DRM. Il y a plein de « solutions » techniques mais en gros ça va à l'encontre de ce pour quoi ce site a été crée (la promotion des Logiciels libres dont le but est fondamentalement de donner le contrôle à l'utilisateur bidouilleur).

https://www.gnu.org/philosophy/opposing-drm.fr.html
https://www.defectivebydesign.org/what_is_drm

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Si tous les utilisateurs sont des « gens de confiance », tu peux aussi bien te passer de mot de passe. Si tu veux vraiment faire chier avec un mot de passe qui sert à rien, met le en clair dans un fichier à côté comme ça tout le monde peut l'examiner/changer facilement. C'est quoi le cas d'utilisation exactement ?

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Il existe d'autres instances Jitsi, certaines ne nécessitant pas d'ouvrir de compte : https://jitsi.github.io/handbook/docs/community/community-instances/

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

https://emmaclit.com/2018/05/28/lhistoire-dun-gardien-de-la-paix/

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

De rien.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

https://web.archive.org/web/20131002073307/http://www.run.montefiore.ulg.ac.be:80/~martin/resources/kung-f00.html
https://web.archive.org/web/20230228041817/https://blog.joren.ga/less-known-c

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Et l'argent pour les entretenir vient du Père Noël ?

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

https://linuxfr.org/users/antistress/liens/vulnerabilites-cpu-ca-continue-amd-inception-et-intel-downfall

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

J'ai écrit ça il y a quelques temps qui fait un truc similaire pour les gens qui ont pas tmux (comme c'était le cas de tout le monde en 2006) : http://cretonnerre.krunch.be/~krunch/src/tcpmux.c

// A select()-based TCP multiplexer. It will accept connections
// on the specified port and send its stdin to connected clients.
// This has nothing to do with the tcpmux service.
// 
// $ cc -Wall -W -pedantic -std=c99 -o tcpmux tcpmux.c
// 
// TODO: select() sucks, use something better
// TODO: turn this into a netcat patch
// TODO: _XOPEN_SOURCE should be in Makefile
// TODO: RESEND should be a command line option
// TODO: are all error conditions checked ?
//
// Copyright (c) 2006 Adrien Kunysz
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

#define _XOPEN_SOURCE  500
//#define RESEND  // data sent by clients are resent to other clients
//#define NDEBUG  // less verbosity

#include <stdio.h>    // stderr, fprintf()
#include <stdlib.h>   // exit(), EXIT_*, atoi(), NULL
#include <string.h>   // memset()
#include <errno.h>    // errno

#include <sys/types.h>   // size_t, ssize_t
#include <sys/socket.h>  // socket(), bind(), listen(), accept(), send(),...
#include <sys/time.h>    // select(), FD_*, fd_set
#include <arpa/inet.h>   // htons()
#include <netinet/in.h>  // INADDR_ANY, sockaddr_in
#include <unistd.h>      // STDIN_FILENO, STDERR_FILENO, close(), read()
#include <fcntl.h>       // fcntl(), F_SETFL, O_NONBLOCK

#define MAX_UNACCEPTED_CONNS  5  // listen()'s second argument
#define MAX_CLIENTS  32
#define BUFSZ  1024

#if MAX_CLIENTS + 2 > FD_SETSIZE
#  error MAX_CLIENTS is too high
#endif

#ifdef NDEBUG
#  define debug(...)
#  define wdebug(buf, len)
#else
#  define debug(...)  fprintf(stderr, __VA_ARGS__)
#  define wdebug(buf, len)  write(STDERR_FILENO, buf, len)
#endif

#define err(...)  do {                                   \
                          fprintf(stderr, __VA_ARGS__);  \
                          exit(EXIT_FAILURE);            \
                  } while (0)

int setup_socket(int portnum)
{
    int res = -1;
    if (-1 == (res = socket(AF_INET, SOCK_STREAM, 0)))
        err("Unable to create socket.\n");
    int yes = 1;
    if (-1 == setsockopt(res, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)))
        fprintf(stderr, "Unable to set SO_REUSEADDR option.\n");
    struct sockaddr_in myaddr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(portnum)
    };
    memset(&(myaddr.sin_zero), '\0', 8);
    if (-1 == bind(res, (struct sockaddr *)&myaddr, sizeof(myaddr)))
        err("Unable to bind address to socket.\n");
    if (-1 == listen(res, MAX_UNACCEPTED_CONNS))
        err("Unable to listen on socket.\n");
    return res;
}

int accept_client(int serverfd)
{
    struct sockaddr_in clientaddr;
    socklen_t addrlen = sizeof(clientaddr);
    int res = accept(serverfd, (struct sockaddr *)&clientaddr, &addrlen);
    if (-1 == res)
        err("accept() failure\n");
    if (-1 == fcntl(res, F_SETFL, O_NONBLOCK))
        fprintf(stderr, "Unable to set non blocking mode on fd.\n");
    return res;
}

size_t sendall(int fd, char *buf, size_t len)
{
    size_t sent = 0;
    while (sent < len) {
        errno = 0;
        ssize_t this_block = send(fd, &buf[sent], len - sent, 0);
        if (0 > this_block) {
            if (EAGAIN == errno || EWOULDBLOCK == errno)
                fprintf(stderr, "Output buffer is full ?\n");
            break;
        }
        sent += (size_t)this_block;
    }
    return sent;
}

int main(int argc, char **argv)
{
    if (2 != argc)
        err("Usage: %s PORT\n", argv[0]);
    const int port = atoi(argv[1]);

    const int inputfd = STDIN_FILENO;
    const int serverfd = setup_socket(port);
    static int clientsfds[MAX_CLIENTS];
    for (unsigned int i = 0; i < MAX_CLIENTS; i++)
        clientsfds[i] = -1;

    static fd_set allfds;
    FD_ZERO(&allfds);
    FD_SET(serverfd, &allfds);
    FD_SET(inputfd, &allfds);

    while (1) {
        static fd_set selectfds;
        selectfds = allfds;
        if (-1 == select(FD_SETSIZE, &selectfds, NULL, NULL, NULL))
            err("select() failure\n");

        if (FD_ISSET(serverfd, &selectfds)) {  // client connection
            debug("Got new client.\n");
            unsigned int fdidx;
            for (fdidx = 1; fdidx < MAX_CLIENTS; fdidx++)
                if (-1 == clientsfds[fdidx])
                    break;
            if (MAX_CLIENTS+1 == fdidx)
                fprintf(stderr, "Too many clients.\n");
            clientsfds[fdidx] = accept_client(serverfd);

            FD_SET(clientsfds[fdidx], &allfds);
            continue;
        }

        static char buf[BUFSZ];
        if (FD_ISSET(inputfd, &selectfds)) {  // input is readable
            ssize_t len = read(inputfd, buf, sizeof(buf));
            if (0 > len)
                err("mysterious read failure\n");
            if (0 == len)  // EOF
                exit(EXIT_SUCCESS);
            size_t ulen = (size_t)len;
            for (unsigned int i = 0; i < MAX_CLIENTS; i++) {
                if (-1 == clientsfds[i])
                    continue;
                if (ulen != sendall(clientsfds[i], buf, ulen))
                    fprintf(stderr, "send() failure\n");
            }
            continue;
        }

        // a client sent something
        unsigned int fdidx;
        for (fdidx = 0; fdidx < MAX_CLIENTS; fdidx++) {
            if (clientsfds[fdidx] == -1)
                continue;
            if (FD_ISSET(clientsfds[fdidx], &selectfds))
                break;
        }
        if (MAX_CLIENTS == fdidx) {  // wtf ? no readable client found
            fprintf(stderr, "select() lied ?\n");
            continue;
        }
        ssize_t len = read(clientsfds[fdidx], buf, sizeof(buf));
        if (0 > len)
            fprintf(stderr, "failed to read from client\n");
        if (0 == len) {  // client closed connection
            FD_CLR(clientsfds[fdidx], &allfds);
            close(clientsfds[fdidx]);
            clientsfds[fdidx] = -1;
            debug("Client disconnected.\n");
            continue;
        }
        wdebug(buf, (size_t)len);
        #ifdef RESEND
        for (unsigned int i = 0; i < MAX_CLIENTS; i++)
            if (-1 != clientsfds[i] && i != fdidx)
                sendall(clientsfds[i], buf, (size_t)len);
        #endif
    }
}

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je lis ça comme « les véhicules actuels ne sont pas adaptés aux voiries modernes mais d'ici quelques années le libre marché devrait avoir réglé le problème ».

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

C'est un peu contradictoire

Je pense que ces deux points venaient d'intervenants différents.
Personnellement j'ai été assez surpris par la position de « les transports en commun c'est une arnaque ».

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

tout le monde (automobiliste ou pas) est obligé d'emprunter une route

Cet argument me semble passablement bancal. J'emprunte relativement régulièrement les routes et autoroutes en tant que passager donc je vois pas trop pourquoi dans un cas il y a un paiement explicite à l'utilisation (auquel, en temps que passager, je vais peut-être participer ou non) et dans l'autre c'est plus indirect (auquel je n'ai pas le choix de si je participe ou non).

On peut aussi examiner le cas de la Belgique ou de l'Allemagne où une proportion significative des usagers autoroutiers résident à l'étranger mais où ces mêmes usagers ne participent généralement pas au financement.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

On peux se poser la question est-ce que la plaque (seul) est-elle vraiment une donnée personnel comme information?

Il y a une réponse authoritative à cette question qui nous permet d'ignorer le reste de ton message : https://www.cnil.fr/fr/definition/donnee-personnelle

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

l’étalement géographique familial : tout le monde n’a pas ses proches habitant dans un rayon de 10 km.

Moi ma famille, elle vit entre 1000 et plus de 10000km de distance, sur 3 continents différents. Je n'utilise pas cette excuse pour prendre la voiture tous les jours.

C'est amusant. Je suis dans une situation similaire, je n'ai pas de voiture et j'ai aussi l'impression qu'il est beaucoup plus courant d'avoir une voiture pour ceux qui sont dans le même pays que leurs proches.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je vois pas comment ça serait possible. Il y a plein de pays qui n'ont pas de péage qui interrompe le flux du trafic mais il y a toujours des coûts pour la maintenance des ces (auto)routes et ils sont payés par quelqu'un.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

C'est comme si je répondais à ton message précédent que si on vit à Crobuzon et qu'on travaille à Yonville, il est impossible ne de pas prendre l'autoroute à péage.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Moi aussi j'évite les autoroutes à payage mais ma technique est un peu différente. Je n'ai pas de voiture.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Le contrôle de vitesse moyenne par tronçon ça existe : https://www.admin.ch/gov/fr/accueil/documentation/communiques.msg-id-43400.html
Même en France apparemment : https://www.securite-routiere.gouv.fr/radars/differents-types-de-radars/radars-fixes/radars-de-controle-de-la-vitesse-fixes

Je ne sais pas pourquoi ça n'est pas plus répandu.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Sauf que l'entropie d'un numéro d'immatriculation est bien plus basse que celle d'un bon mot de passe. D'après https://fr.wikipedia.org/wiki/Plaque_d%27immatriculation_fran%C3%A7aise#Num%C3%A9rotation on est à moins de 3*10⁸ possibilités. Un mot de passe de 8 caractères avec juste des lettres minuscules (assez bien pourri donc) c'est plus de 10^11. Dans ce contexte le hashage ne me semble pas apporter énormément d'avantage contre les attaques et casse complètement le cas d'utilisation (légitime) décrit dans ce journal.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je ne me fie jamais à rien venant de la SNCF, et c'est d'ailleurs ce qui rend mes voyages en train pénibles (je suis toujours stressé qu'une embrouille survienne).

Je compatis. J'ai le même sentiment quand je dois prendre le train en France ou en Belgique et ça me fait souvent préférer des moyens alternatifs (e.g. passer par l'Allemagne ou prendre le bus).

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

je préfèrerais savoir comment ça se passe dans d'autres pays

Mon expérience dans les pays dans lesquels j'ai beaucoup voyagé en train.

Belgique : il y a un quai habituel mais en pratique ça varie assez souvent. L'affichage du quai se fait ~10 minutes avant l'entrée en gare. Des fois ils changent le quai juste avant que le train arrive. En tout cas c'était mon expérience vers 2002-2010. J'ai l'impression que ça s'est un peu amélioré mais je n'y prend plus le train si souvent. Les annonces sonores restent souvent incompréhensibles (même quand elles sont en théorie dans la bonne langue).

Angleterre : dans les grandes gares il n'y a pas vraiment de quai habituel annoncé. L'affichage du quai se fait ~5 minutes avant l'entrée en gare. Je me souviens pas avoir eu un changement de quai après ce moment. Les annonces sonores sont généralement nombreuses et compréhensibles.

Suisse : il y a un quai habituel annoncé. Quand ça varie, le nouveau quai est généralement annoncé plusieurs heures à l'avance. La quantité des annonces sonores varie mais je dois avouer que j'y fais plus du tout attention.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Je suspecte que la raison sous-jacente est liée à un impératif de rentabilité de l'actionnaire alors que par nature c'est un service qui ne peut pas être rentable, surtout quand la compétition a des avantages légaux (kérosène non taxé) et/ou infrastructurels conséquents (e.g. il y a des routes partout et personne se plaint qu'elles sont pas rentables (je parle pas des autoroutes)). Tu combines ça avec des lois sur le travail qui rendent l'emploi relativement couteux et tu te retrouves à sous traiter/externaliser.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.