Krunch a écrit 3997 commentaires

https://linuxfr.org/users/krunch/journaux/dlfp-hacke

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

https://www.cbr.com/fables-dc-statement-not-public-domain/
https://pluralistic.net/2023/09/15/fairy-use-tales/

Doublon sur DLFP : https://linuxfr.org/users/hellpe/liens/l-auteur-des-comics-dc-fables-declare-placer-son-oeuvre-dans-le-domaine-public

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

https://billwillingham.substack.com/p/more-about-fables-in-the-public-domain

Ça n'a pas l'air de répondre aux questions soulevées dans les commentaires ici.

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

J'avais jamais entendu parler de l'auteur ou de l'oeuvre avant aujourd'hui je dois dire.

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

C'est sympa de vouloir déplacer le goal mais « se nourrir à sa faim » n'est pas une métrique que tu as cité plus haut.

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

Ah ben du coup mon commentaire devrait être moinssé.

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

https://linuxfr.org/users/krunch/liens/la-depression-et-l-anxiete-se-transmettent-d-une-entreprise-a-l-autre-par-les-employes
https://linuxfr.org/users/krunch/liens/etude-ethnographique-du-controle-normatif-dans-une-entreprise-high-tech
https://business.uzh.ch/dam/jcr:ef9412a8-59a3-4cc4-b9a3-9c66aeb8d816/Menges_et_al__2010__Strategic_Emo_Int_RES_ORG_BEHAVE.pdf

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

Je suspecte que le moinssage de ton commentaire au demeurant extrêmement pertinent de mon expérience est une réflexion de cette dissonance cognitive.

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

Esperance de vie

En diminution depuis 2014 dans le pays à la pointe du capitalisme.

temps libre

Pas forcément évident à mesurer mais de ce que je comprend, la plupart des gens avaient plus de temps libre sous un régime féodal.

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

Aucune idée de ce que c'est qu'Hafas. Il me semble avoir eu le problème en essayant de commander sur le (un ?) site de la SNCF puis au guichet CFF.

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

D'autres réclament que seul le fournisseur d'un logiciel puisse fournir une évaluation (comme le CVSS).

Je pense que les métriques telles que CVSS peuvent rapidement dépendre de comment le logiciel est utilisé. Ça n'est pas forcément quelque chose sur lequel le fournisseur a beaucoup de visibilité. Pour CVSSv2 il s'agit notamment des métriques qui mesurent l'impact environnemental (non, l'autre). Pour CVSSv3 c'est le vecteur modifié. CVSSv4 semble renforcer ces concepts : https://www.first.org/cvss/v4-0/

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

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.