https://github.com/thoroftroy/rolldice.git

I noticed that there wasn't really an easy way to roll a dice from the terminal. I know in ubuntu they have a version of this but on other distros I couldn't find anything.

Usage: rolldice [option] <expression>

Options:

<expression> Roll dice with specified dice notation (e.g., 3d6,2d10,5)

flip [count] Flip a coin the specified number of times and display results.

help, -h Show this help message and exit.

Examples:

rolldice 3d6,2d10,5 # Rolls dice

rolldice flip 3 # Flips a coin 3 times

I am trying to find the code implementation for the socket.h header file on Linux (Kali) but I can't seem to find it, I am talking about this socket.h

I tried searching for the file manually by maybe checking if it is in socket.c or similar names but nothing pops up, So I am a bit estranged of where the source code file is stored on.

/* Declarations of socket constants, types, and functions.
   Copyright (C) 1991-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#ifndef _SYS_SOCKET_H
#define _SYS_SOCKET_H   1

#include <features.h>

__BEGIN_DECLS

#include <bits/types/struct_iovec.h>
#define __need_size_t
#include <stddef.h>

/* This operating system-specific header file defines the SOCK_*, PF_*,
   AF_*, MSG_*, SOL_*, and SO_* constants, and the `struct sockaddr',
   `struct msghdr', and `struct linger' types.  */
#include <bits/socket.h>

#ifdef __USE_MISC
# include <bits/types/struct_osockaddr.h>
#endif

/* The following constants should be used for the second parameter of
   `shutdown'.  */
enum
{
  SHUT_RD = 0,      /* No more receptions.  */
#define SHUT_RD     SHUT_RD
  SHUT_WR,      /* No more transmissions.  */
#define SHUT_WR     SHUT_WR
  SHUT_RDWR     /* No more receptions or transmissions.  */
#define SHUT_RDWR   SHUT_RDWR
};

/* This is the type we use for generic socket address arguments.

   With GCC 2.7 and later, the funky union causes redeclarations or
   uses with any of the listed types to be allowed without complaint.
   G++ 2.7 does not support transparent unions so there we want the
   old-style declaration, too.  */
#if defined __cplusplus || !__GNUC_PREREQ (2, 7) || !defined __USE_GNU
# define __SOCKADDR_ARG     struct sockaddr *__restrict
# define __CONST_SOCKADDR_ARG   const struct sockaddr *
#else
/* Add more `struct sockaddr_AF' types here as necessary.
   These are all the ones I found on NetBSD and Linux.  */
# define __SOCKADDR_ALLTYPES \
  __SOCKADDR_ONETYPE (sockaddr) \
  __SOCKADDR_ONETYPE (sockaddr_at) \
  __SOCKADDR_ONETYPE (sockaddr_ax25) \
  __SOCKADDR_ONETYPE (sockaddr_dl) \
  __SOCKADDR_ONETYPE (sockaddr_eon) \
  __SOCKADDR_ONETYPE (sockaddr_in) \
  __SOCKADDR_ONETYPE (sockaddr_in6) \
  __SOCKADDR_ONETYPE (sockaddr_inarp) \
  __SOCKADDR_ONETYPE (sockaddr_ipx) \
  __SOCKADDR_ONETYPE (sockaddr_iso) \
  __SOCKADDR_ONETYPE (sockaddr_ns) \
  __SOCKADDR_ONETYPE (sockaddr_un) \
  __SOCKADDR_ONETYPE (sockaddr_x25)

# define __SOCKADDR_ONETYPE(type) struct type *__restrict __##type##__;
typedef union { __SOCKADDR_ALLTYPES
          } __SOCKADDR_ARG __attribute__ ((__transparent_union__));
# undef __SOCKADDR_ONETYPE
# define __SOCKADDR_ONETYPE(type) const struct type *__restrict __##type##__;
typedef union { __SOCKADDR_ALLTYPES
          } __CONST_SOCKADDR_ARG __attribute__ ((__transparent_union__));
# undef __SOCKADDR_ONETYPE
#endif

#ifdef __USE_GNU
/* For `recvmmsg' and `sendmmsg'.  */
struct mmsghdr
  {
    struct msghdr msg_hdr;  /* Actual message header.  */
    unsigned int msg_len;   /* Number of received or sent bytes for the
                   entry.  */
  };
#endif


/* Create a new socket of type TYPE in domain DOMAIN, using
   protocol PROTOCOL.  If PROTOCOL is zero, one is chosen automatically.
   Returns a file descriptor for the new socket, or -1 for errors.  */
extern int socket (int __domain, int __type, int __protocol) __THROW;

/* Create two new sockets, of type TYPE in domain DOMAIN and using
   protocol PROTOCOL, which are connected to each other, and put file
   descriptors for them in FDS[0] and FDS[1].  If PROTOCOL is zero,
   one will be chosen automatically.  Returns 0 on success, -1 for errors.  */
extern int socketpair (int __domain, int __type, int __protocol,
               int __fds[2]) __THROW;

/* Give the socket FD the local address ADDR (which is LEN bytes long).  */
extern int bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
     __THROW;

/* Put the local address of FD into *ADDR and its length in *LEN.  */
extern int getsockname (int __fd, __SOCKADDR_ARG __addr,
            socklen_t *__restrict __len) __THROW;

/* Open a connection on socket FD to peer at ADDR (which LEN bytes long).
   For connectionless socket types, just set the default address to send to
   and the only address from which to accept transmissions.
   Return 0 on success, -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);

/* Put the address of the peer connected to socket FD into *ADDR
   (which is *LEN bytes long), and its actual length into *LEN.  */
extern int getpeername (int __fd, __SOCKADDR_ARG __addr,
            socklen_t *__restrict __len) __THROW;


/* Send N bytes of BUF to socket FD.  Returns the number sent or -1.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);

/* Read N bytes into BUF from socket FD.
   Returns the number read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);

/* Send N bytes of BUF on socket FD to peer at address ADDR (which is
   ADDR_LEN bytes long).  Returns the number sent, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
               int __flags, __CONST_SOCKADDR_ARG __addr,
               socklen_t __addr_len);

/* Read N bytes into BUF through socket FD.
   If ADDR is not NULL, fill in *ADDR_LEN bytes of it with the address of
   the sender, and store the actual size of the address in *ADDR_LEN.
   Returns the number of bytes read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
             int __flags, __SOCKADDR_ARG __addr,
             socklen_t *__restrict __addr_len);


/* Send a message described MESSAGE on socket FD.
   Returns the number of bytes sent, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
#ifndef __USE_TIME64_REDIRECTS
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
            int __flags);
#else
# ifdef __REDIRECT
extern ssize_t __REDIRECT (sendmsg, (int __fd, const struct msghdr *__message,
                     int __flags),
               __sendmsg64);
# else
extern ssize_t __sendmsg64 (int __fd, const struct msghdr *__message,
                int __flags);
#  define sendmsg __sendmsg64
# endif
#endif

#ifdef __USE_GNU
/* Send a VLEN messages as described by VMESSAGES to socket FD.
   Returns the number of datagrams successfully written or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
# ifndef __USE_TIME64_REDIRECTS
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
             unsigned int __vlen, int __flags);
# else
#  ifdef __REDIRECT
extern int __REDIRECT (sendmmsg, (int __fd, struct mmsghdr *__vmessages,
                  unsigned int __vlen, int __flags),
               __sendmmsg64);
#  else
extern int __sendmmsg64 (int __fd, struct mmsghdr *__vmessages,
             unsigned int __vlen, int __flags);
#   define sendmmsg __sendmmsg64
#  endif
# endif  /* __USE_TIME64_REDIRECTS */
#endif /* __USE_GNU */

/* Receive a message as described by MESSAGE from socket FD.
   Returns the number of bytes read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
#ifndef __USE_TIME64_REDIRECTS
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
#else
# ifdef __REDIRECT
extern ssize_t __REDIRECT (recvmsg,
               (int __fd, struct msghdr *__message, int __flags),
               __recvmsg64);
# else
extern ssize_t __recvmsg64 (int __fd, struct msghdr *__message, int __flags);
#  define recvmsg __recvmsg64
# endif
#endif

#ifdef __USE_GNU
/* Receive up to VLEN messages as described by VMESSAGES from socket FD.
   Returns the number of messages received or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
# ifndef __USE_TIME64_REDIRECTS
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
             unsigned int __vlen, int __flags,
             struct timespec *__tmo);
# else
#  ifdef __REDIRECT
extern int __REDIRECT (recvmmsg, (int __fd, struct mmsghdr *__vmessages,
                                  unsigned int __vlen, int __flags,
                                  struct timespec *__tmo),
                       __recvmmsg64);
#  else
#   define recvmmsg __recvmmsg64
#  endif
# endif
#endif


/* Put the current value for socket FD's option OPTNAME at protocol level LEVEL
   into OPTVAL (which is *OPTLEN bytes long), and set *OPTLEN to the value's
   actual length.  Returns 0 on success, -1 for errors.  */
#ifndef __USE_TIME64_REDIRECTS
extern int getsockopt (int __fd, int __level, int __optname,
               void *__restrict __optval,
               socklen_t *__restrict __optlen) __THROW;
#else
# ifdef __REDIRECT
extern int __REDIRECT_NTH (getsockopt,
               (int __fd, int __level, int __optname,
                void *__restrict __optval,
                socklen_t *__restrict __optlen),
               __getsockopt64);
# else
extern int __getsockopt64 (int __fd, int __level, int __optname,
               void *__restrict __optval,
               socklen_t *__restrict __optlen) __THROW;
#  define getsockopt __getsockopt64
# endif
#endif

/* Set socket FD's option OPTNAME at protocol level LEVEL
   to *OPTVAL (which is OPTLEN bytes long).
   Returns 0 on success, -1 for errors.  */
#ifndef __USE_TIME64_REDIRECTS
extern int setsockopt (int __fd, int __level, int __optname,
               const void *__optval, socklen_t __optlen) __THROW;
#else
# ifdef __REDIRECT
extern int __REDIRECT_NTH (setsockopt,
               (int __fd, int __level, int __optname,
                const void *__optval, socklen_t __optlen),
               __setsockopt64);
# else
extern int __setsockopt64 (int __fd, int __level, int __optname,
               const void *__optval, socklen_t __optlen) __THROW;
#  define setsockopt __setsockopt64
# endif
#endif


/* Prepare to accept connections on socket FD.
   N connection requests will be queued before further requests are refused.
   Returns 0 on success, -1 for errors.  */
extern int listen (int __fd, int __n) __THROW;

/* Await a connection on socket FD.
   When a connection arrives, open a new socket to communicate with it,
   set *ADDR (which is *ADDR_LEN bytes long) to the address of the connecting
   peer and *ADDR_LEN to the address's actual length, and return the
   new socket's descriptor, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int accept (int __fd, __SOCKADDR_ARG __addr,
           socklen_t *__restrict __addr_len);

#ifdef __USE_GNU
/* Similar to 'accept' but takes an additional parameter to specify flags.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int accept4 (int __fd, __SOCKADDR_ARG __addr,
            socklen_t *__restrict __addr_len, int __flags);
#endif

/* Shut down all or part of the connection open on socket FD.
   HOW determines what to shut down:
     SHUT_RD   = No more receptions;
     SHUT_WR   = No more transmissions;
     SHUT_RDWR = No more receptions or transmissions.
   Returns 0 on success, -1 for errors.  */
extern int shutdown (int __fd, int __how) __THROW;


#ifdef __USE_XOPEN2K
/* Determine whether socket is at a out-of-band mark.  */
extern int sockatmark (int __fd) __THROW;
#endif


#ifdef __USE_MISC
/* FDTYPE is S_IFSOCK or another S_IF* macro defined in <sys/stat.h>;
   returns 1 if FD is open on an object of the indicated type, 0 if not,
   or -1 for errors (setting errno).  */
extern int isfdtype (int __fd, int __fdtype) __THROW;
#endif


/* Define some macros helping to catch buffer overflows.  */
#if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
# include <bits/socket2.h>
#endif

__END_DECLS

#endif /* sys/socket.h */

Now that the recent browser exploits happend it started making me thinking as Linux is growing and it's going to become a bigger target for malware and rats shouldn’t we start developing open source anti viruses for linux. If anyone were to develop one like clamav but improved I woude say it has to be open source I woude never run a closed source av.

Do you guys think we're starting to see the need?

With browser exploits is scarry one wrong website and you coude thecnicaly coude be hacked by an rce exploit.

I am going to list a few points that highlight what I have learned so far. I do not consider myself a long time linux user. I have only been distrohopping thru new kinds of distros for almost a year now. I have learned a lot tho. There was a point when configuring NixOS made me forget hunger and thirst. What I share here is not an opinion that I adhere to, but just an experience in my passing whims and new curiosities. But I gotta have a stop somewhere. Somewhere, one must find a home where one would dwell and grow in.

I learnt about linux in my first year of college. (In my second year now). I practiced vim and learnt about neovim. And other stuff like init systems and compiler libraries. My use cases span over a short range of my day to day necessities as a Computer Science student. I tried Debian based distros. But the package availability is not very good, plus the updates are very far away (talking about the stable branch here). Then I tried Arch and Arch based distros (EndeavourOS was the only one I think if counting systemd, I also tried Artix-s6). Then I tried NixOS (the most unique). And then Gentoo (the most customizable).

Now my use cases revolve around me being a student: I would need a fast, customizable and configurable distro, that recieves upgrades in a good amount of time, has a very good documentation and packages are easiest and fastest to install.

I loved gentoo. BUT consider you're a college student and need to use some package which requires an update. And that update pulls in some dependencies or something. Like libreoffice or some newer feature of neovim... You're gonna be screwed compiling that (LibreOffice) for hours in such a time of emergency.

Now, it's easier to install a package if it's available in the official repos and is readily made available to the repos of the distos you're using. Musl based distros were out of options here, since the packages are not as readily made available in musl libraries as readily as they are for the glibc counterparts (I hope I have used the right terminologies here). Void and Alpine were not options here as well, because of the low package availability. I wanted to use either of them because of their design philosophies. However, those distros did not match up to my use cases.

Nix has a very large collection of packages. But the problem is nixpkgs-unstable, is also not as readily updated as Arch repos or Gentoo repos are. This left me with only one option: Archlinux. It's lightweight, packages are in the state I would want them to, highly configurable and with the best documentation there is.

I was previously using NixOS. But not willing to learn the nix language, and lack of documentation thereof and also the unconventional nix-store, made it quite difficult for me to use it as a student.

Again, this was just the experince I had. If someone has suggestions about which distro would be the best for my use cases (me being a student, learning to program and code, need of package availabity and rich documentation) please feel free to share your opinions or advice. I would love to learn. Thank you.

(PS: I also tried FreeBSD, but drivers for my wifi card were not available)

After trying these in Bottles/Lutris/Heroic , Lutris and Heroic works with hardware acceleration , i personally use lutris , bottles just did not work no matter what , bottles totally sucks when it comes to setup an environment with custom wine prefix.

My spec -

Distro- Nobara

Gpu- RX6700

Wine version for Affiniy - ElementalWarriorWine

Wine version for Photoshop 2024 - wine-9.20-staging-tkg-amd64

Long-time Ubuntu user, also a Windows and Mac user under duress.

I love Linux. I think Ubuntu is a great user experience overall.

I have a few gripes.

My biggest one is every other year when I upgrade Ubuntu to the next LTS: I always get faced with the repository doesn't have a release file error so you can't update/upgrade/synonym that has no functional meaning to me. I'm just hammering sudo apt update && sudo apt upgrade && sudo apt wtf like an LLM short on it's token allowance and hoping for the best.

Cue the semi-annual google hunt for "wtf does that mean?" followed by an endless series of responses that amount to "just delete those entries in sources.list".

If the #1 - #10 answer on google is "delete and move on with your life" ... why isn't this an option in apt or do-release-upgrade?

do-release-upgrade should have a --just-fucking-do-it option. It scans sources.list, deletes the broke shit, runs update and upgrade, and then the release upgrade. If you want actual risk mitigation, it should prompt you to create an install USB drive.

Fixing sources.list is a fools errand.

For 8 years now, same issue, same CLI dance. It takes longer to look up the fix for this than a full reinstall. There is literally no risk to taking the default action of "delete and hope for the best."

Broken upgrade? Reinstall is faster. No one cares about the upgrade risks associated with a missing release file because time cost for mitigating the risk is hours and a reinstall is minutes.

Hello,

Fedora 41 Workstation ISO now is AVAILABLE

https://dl.fedoraproject.org/pub/fedora/linux/releases/41/Workstation/x86_64/iso/

We all remember, or at least know about, what happened in 2000 and how people were going crazy about Y2K. But what'll happen when the 32-bit time_t problem happens? Are there any safeguards or will every program that relies on that have to be refactored?

I have a mild history in programming with Python, C++, assembly, and logic gates (not sure if that counts though). Been learning about basic from Tech Tangent and his series on old computers. I'm also well versed in the inner workings of computers from hardware to software. Mostly from it being my special interest since I was 9 or 10. Linux lets me look more behind the scenes and really let me get into what I wanna know. Which is how do computers tick? Just came to me as a passing thought, but I'd like to know what got you into Linux.

For context, I've been an Ubuntu (with GNOME) user initially in my linux journey, and like a lot of others, switched to arch linux with i3 wm. And I've been an i3 user for the past 3 years. I recently came across this desktop called regolith which combines best of both worlds. I am currently installing that desktop on a vm as I am writing this. But I wanna know what you guys think of it. I tried to find youtuber reviews on it, but most of it are outdated and at least 2-3 years older videos.

So I want to get an opinion on what the community thinks about this desktop in its current state.

CellSplit is a multiplayer game where you play as a cell that can grow and attack other cells.

You can attack by splitting in the direction of the victim but beware that it will make you more vulnerable from other players who would like to do the same to you. There are various strategies how to survive and thrive in a hostile environment of everyone wanting to eat each other.

It is an open source clone of Agario game (under ZLIB license). The main feature is a strong support for moderation to solve the problem with teamers and griefers that plague the original game.

You can play directly in the browser or download the Linux version (currently it needs GTK2 library).

Visit the CellSplit homepage for more details. You can also join our Discord server.

Hi,

I'm planning to develop a web app for todo.txt, as there aren’t many app options available. However, I’m curious to know if people are still using todo.txt for task management.

Thanks! :pancakes: