Dijkstracula fucked around with this message at 16:14 on Jan 9, 2023

// x must be a pointer to an array of exactly length 3
void foo(int (*x)[3]) {
  printf ("%d %d %d", (*x)[0],(*x)[1], (*x)[2]);
  
  // or equivalently:
  int* arr = *x;
  printf ("%d %d %d", arr[0], arr[1], arr[2]);
}

int main(void) {
  // compiles:
  int bar[3] = {3, 5, 7};
  foo(&bar);

  //does not compile:
  int baz[4] = {3, 9, 29, 81};
  foo(&baz);
 
  //doesn't work with a malloc'd array either, since the type is int**
  int qux = malloc(3 * sizeof(int));
  foo(&qux);
}

RPATDO_LAMD fucked around with this message at 21:37 on Jan 9, 2023

OddObserver fucked around with this message at 19:30 on Jan 10, 2023

Most often (3 times): 0.200000 -9.900000 0.200000 -9.900000 0.200000 -9.900000

Ihmemies fucked around with this message at 16:59 on Jan 15, 2023

-293: short int, int
7608: short int, unsigned short int, int
-127: signed char, short int, int
1234567: int
0: signed char, unsigned char, short int, unsigned short int, int

int main(int argc, char *argv[])
{
    int value;
    int i = 1;
    int sep = -1;

    for (; i < argc; i++) {
        value = atoi(argv[i]);
        sep = -1;

        printf("%d:", value);

        /* research the amount of separators needed */
        if (value >= -128 && value <= 127) {
            sep++;
        }
        if (value >= 0 && value <= 255) {
            sep++;
        }
        if (value >= -32768 && value <= 32767) {
            sep++;
        }
        if (value >= 0 && value <= 65535) {
            sep++;
        }
        if (value >= -2147483647 && value <= 2147483647) {
            sep++;
        }

        if (value >= SCHAR_MIN && value <= SCHAR_MAX) {
            printf(" signed char");
            if (sep > 0) {
                putchar(',');
                sep--;
            }
        }
        if (value >= 0 && value <= UCHAR_MAX) {
            printf(" unsigned char");
            if (sep > 0) {
                putchar(',');
                sep--;
            }
        }
        if (value >= SHRT_MIN && value <= SHRT_MAX) {
            printf(" short int");
            if (sep > 0) {
                putchar(',');
                sep--;
            }
        }
        if (value >= 0 && value <= USHRT_MAX) {
            printf(" unsigned short int");
            if (sep > 0) {
                putchar(',');
                sep--;
            }
        }
        if (value >= INT_MIN && value <= INT_MAX) {
            printf(" int");
            if (sep > 0) {
                putchar(',');
                sep--;
            }
        }

        putchar('\n');

    }

    return 0;
}

Ihmemies fucked around with this message at 17:35 on Jan 17, 2023

static unsigned int sslpsk_psk_server_callback(SSL *ssl,
                                               const char *identity,
                                               unsigned char *psk,
                                               unsigned int max_psk_lens)
{
    std::cout << "identity : " << identity<< std::endl;
    strncpy((char*)psk,"foo", 3);
    return 3;
}

int main()
{

    boost::asio::ssl::context ssl_context(boost::asio::ssl::context::tls_server);
//    ssl_context.set_options(boost::asio::ssl::context::default_workarounds
//                            | boost::asio::ssl::context::no_sslv2);
    ssl_context.set_verify_mode(boost::asio::ssl::verify_peer);
    SSL_CTX_set_cipher_list(ssl_context.native_handle(),"TLS_CHACHA20_POLY1305_SHA256");
    boost::asio::io_context ctx;
    boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket(ctx, ssl_context);    
    SSL_set_psk_server_callback(socket.native_handle(), sslpsk_psk_server_callback);
    SSL_set_accept_state(socket.native_handle());

    boost::asio::ip::tcp::acceptor acceptor(socket.get_executor(),
                                            boost::asio::ip::tcp::endpoint(
                                                boost::asio::ip::make_address("127.0.0.1"),4567));
    acceptor.listen();
    for(;;)
    {
        boost::asio::ssl::stream<boost::asio::ip::tcp::socket> client(ctx,ssl_context);
        acceptor.accept(client.next_layer());       
        std::cout << "client connected"<<std::endl;
        client.handshake(boost::asio::ssl::stream_base::server);
        boost::asio::write(client, boost::asio::buffer("abc",3));
    }

    return 0;
}

unsigned int sslpsk_psk_client_callback(SSL* ssl,
                                               const char* hint,
                                               char* identity,
                                               unsigned int max_identity_len,
                                               unsigned char* psk,
                                               unsigned int max_psk_len)
{
    std::cout << "hint : " << hint<< std::endl;
    strncpy((char*)identity,"cli", 3);
    identity[3]=0;
    strncpy((char*)psk,"foo", 3);
    psk[3]=0;
    return 3;
}

int main()
{
    boost::asio::ssl::context ssl_context(boost::asio::ssl::context::tls_client);
//    ssl_context.set_options(boost::asio::ssl::context::default_workarounds
//                            | boost::asio::ssl::context::no_sslv2);
//    ssl_context.set_verify_mode(boost::asio::ssl::verify_peer);
    SSL_CTX_set_cipher_list(ssl_context.native_handle(),"TLS_CHACHA20_POLY1305_SHA256");
    boost::asio::io_context ctx;
    boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket(ctx, ssl_context);
    SSL_set_psk_client_callback(socket.native_handle(), sslpsk_psk_client_callback);
    SSL_set_connect_state(socket.native_handle());
    boost::asio::ip::tcp::resolver resolver(ctx);
    boost::asio::connect(socket.next_layer(),resolver.resolve("127.0.0.1","4567"));
    socket.handshake(boost::asio::ssl::stream_base::client);
    std::cout << "connected\n";
    char data[3];
    boost::asio::read(socket,boost::asio::buffer(data,3));

    std::cout << data<< std::endl;

    return 0;
}

Volguus fucked around with this message at 07:51 on Jan 21, 2023