DEV Community: SATO, Yoshiyuki

Passwordless encryption with public key for GitHub

SATO, Yoshiyuki — Mon, 15 May 2023 00:57:28 +0000

Public keys registered for authentication on GitHub and GitLab can be obtained by anyone. I made a command that can encrypt/decrypt files using that public key and own private key.

This command can handle encrypted files without a password. Of course it is necessary if a passphrase is registered with the private key. However, there is no need to pass the password from the sender to the recipient.

I named the command git-caesar. Don't worry, I don't use the Caesar cipher.

It's a new command, so there may be bugs.
I'm not familiar with encryption technology, so I'm looking forward to hearing from people who know more.

This command is heavily influenced by QiiCipher.
QiiCipher is also a shell script-based tool that encrypts/decrypts small files using RSA public keys for GitHub.
QiiCipher is intended to be implemented with the minimum requirements of standard shell functions + OpenSSL/OpenSSH, while this command is implemented in the GO language to make it easier to handle.

Public key for GitHub and GitLab authentication

I think it's common to register a public key for ssh in GitHub or GitLab for authentication during git push.
Anyone can obtain this registered public key.

GitHub public key URL: https://github.com/USER_NAME.keys
GitLab public key URL: https://gitlab.com/USER_NAME.keys

These public keys are primarily for signing, but some algorithms can also be used for encryption.
Using this public key, passwordless encryption/decryption is realized.
Public key encryption algorithms support RSA (key length of 1024 bits or more), ECDSA, and ED25519.

RSA (key length of 1024 bits or more)
- public key prefix: ssh-rsa
ECDSA
- P256 -- public key prefix: ecdsa-sha2-nistp256
- P384 -- public key prefix: ecdsa-sha2-nistp384
- P521 -- public key prefix: ecdsa-sha2-nistp521
ED25519 -- public key prefix: ssh-ed25519

Others, namely DSA, ECDSA-SK and ED25519-SK for secret keys, and RSA with key length less than 1024 bits are not supported.

DSA -- Excluded from GitHub/GitLab due to deprecation and lack of research on how to implement it.
- public key prefix: ssh-dss
ECDSA-SK, ED25519-SK -- As far as I have researched, I have determined that this is not possible. At least, it cannot be achieved simply by using a library.
- public key prefix: sk-ecdsa-sha2-nistp256@openssh.com
- public key prefix: sk-ssh-ed25519@openssh.com
RSA (key length less than 1024 bits) -- determined to be a security problem. Also, since the key length is short, there are restrictions on key encryption.

Message body encryption

Even when public-key cryptography is used, it is common to encrypt the body of the message with symmetric-key cryptography.
This command uses symmetric key encryption method AES in AES-256-CBC mode.

package aes

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
)

func Encrypt(key, plaintext []byte) ([]byte, error) {
    // pad the message with PKCS#7
    padding := aes.BlockSize - len(plaintext)%aes.BlockSize
    padtext := append(plaintext, bytes.Repeat([]byte{byte(padding)}, padding)...)

    ciphertext := make([]byte, aes.BlockSize+len(padtext))
    iv := ciphertext[:aes.BlockSize]
    encMsg := ciphertext[aes.BlockSize:]

    // generate initialization vector (IV)
    _, err := rand.Read(iv)
    if err != nil {
        return nil, err
    }

    // encrypt message (AES-CBC)
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    cbc := cipher.NewCBCEncrypter(block, iv)
    cbc.CryptBlocks(encMsg, padtext)

    return ciphertext, nil
}

func Decrypt(key, ciphertext []byte) ([]byte, error) {
    // extract the initial vector (IV)
    iv := ciphertext[:aes.BlockSize]
    encMsg := ciphertext[aes.BlockSize:]

    // create an decrypter in CBC mode
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    cbc := cipher.NewCBCDecrypter(block, iv)

    // decrypt ciphertext
    msgLen := len(encMsg)
    decMsg := make([]byte, msgLen)
    cbc.CryptBlocks(decMsg, encMsg)

    // Unpad the message with PKCS#7
    plaintext := decMsg[:msgLen-int(decMsg[msgLen-1])]
    return plaintext, nil
}

First, prepare a shared key (32 bytes = 256 bits) by some method, such as random numbers or key exchange.
Encrypt with AES-256-CBC using that shared key.
A random number called an initialization vector (IV) is required for encryption.
An IV is like a salt when hashing a password, so that even if the same data is encrypted, the ciphertext will be different. This is fine to publish.
This IV must be passed to the recipient, so I insert it at the beginning of the ciphertext.
When receiving, the first block is extracted as IV and then decoded.

Also, AES-256-CBC requires padding that matches the block length.
There are several methods of padding, but this time we use the PKCS#7 method.

The ciphertext can be passed as it is, but the important point is how to share the shared key used for encryption with the other party.

For RSA public keys

RSA public keys are limited to small enough data, but can also be used for encryption.
However, primitive encryption methods are difficult for unskilled humans to master (for example, it is easy to make mistakes like using block ciphers in ECB cipher mode). So I used RSA-OAEP, a cipher suite using RSA.

package rsa

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
)

func Encrypt(pubKey *rsa.PublicKey, plaintext []byte) ([]byte, error) {
    return rsa.EncryptOAEP(sha256.New(), rand.Reader, pubKey, plaintext, []byte{})
}

func Decrypt(prvKey *rsa.PrivateKey, ciphertext []byte) ([]byte, error) {
    return rsa.DecryptOAEP(sha256.New(), rand.Reader, prvKey, ciphertext, []byte{})
}

func Sign(prvKey *rsa.PrivateKey, message []byte) ([]byte, error) {
    hash := sha256.Sum256(message)
    return rsa.SignPKCS1v15(rand.Reader, prvKey, crypto.SHA256, hash[:])
}

func Verify(pubKey *rsa.PublicKey, message, sig []byte) bool {
    hash := sha256.Sum256(message)
    err := rsa.VerifyPKCS1v15(pubKey, crypto.SHA256, hash[:], sig)
    return err == nil
}

As a result of testing, if the RSA key length is about 800 bits, it seems that a 32-byte key can be encrypted.
Since the key length supported this time is 1024 bits or more, a 32-byte key can be encrypted without problems.

The shared key for AES-256-CBC is encrypted using the recipient's RSA public key and sent to the other party, who can then decrypt it with their own RSA private key.

For ECDSA public keys

ECDSA is an algorithm for signing. Therefore, it cannot be used directly for encryption/decryption.
Related to ECDSA is the ECDH key exchange algorithm, and ECDSA keys can be used almost as is for ECDH.
And if you use key exchange, the sender uses "sender's private key" and "recipient's public key", and the receiver uses "recipient's private key" and "sender's public key" You can get the same key by exchanging the key.

When using this exchanged key to encrypt/decrypt with a symmetric key encryption system such as AES, there is no need to pass the key itself.

package ecdsa

import (
    "crypto/ecdsa"
    "crypto/rand"
    "crypto/sha256"
    "encoding/asn1"
    "math/big"

    "github.com/yoshi389111/git-caesar/caesar/aes"
)

func Encrypt(peersPubKey *ecdsa.PublicKey, message []byte) ([]byte, *ecdsa.PublicKey, error) {
    curve := peersPubKey.Curve

    // generate temporary private key
    tempPrvKey, err := ecdsa.GenerateKey(curve, rand.Reader)
    if err != nil {
        return nil, nil, err
    }

    // key exchange
    exchangedKey, _ := curve.ScalarMult(peersPubKey.X, peersPubKey.Y, tempPrvKey.D.Bytes())
    sharedKey := sha256.Sum256(exchangedKey.Bytes())

    // encrypt AES-256-CBC
    ciphertext, err := aes.Encrypt(sharedKey[:], message)
    if err != nil {
        return nil, nil, err
    }
    return ciphertext, &tempPrvKey.PublicKey, nil
}

func Decrypt(prvKey *ecdsa.PrivateKey, peersPubKey *ecdsa.PublicKey, ciphertext []byte) ([]byte, error) {
    curve := prvKey.Curve

    // key exchange
    exchangedKey, _ := curve.ScalarMult(peersPubKey.X, peersPubKey.Y, prvKey.D.Bytes())
    sharedKey := sha256.Sum256(exchangedKey.Bytes())

    // decrypt AES-256-CBC
    return aes.Decrypt(sharedKey[:], ciphertext)
}

type sigParam struct {
    R, S *big.Int
}

func Sign(prvKey *ecdsa.PrivateKey, message []byte) ([]byte, error) {
    hash := sha256.Sum256(message)
    r, s, err := ecdsa.Sign(rand.Reader, prvKey, hash[:])
    if err != nil {
        return nil, err
    }
    sig, err := asn1.Marshal(sigParam{R: r, S: s})
    if err != nil {
        return nil, err
    }
    return sig, nil
}

func Verify(pubKey *ecdsa.PublicKey, message, sig []byte) bool {
    hash := sha256.Sum256(message)
    signature := &sigParam{}
    _, err := asn1.Unmarshal(sig, signature)
    if err != nil {
        return false
    }
    return ecdsa.Verify(pubKey, hash[:], signature.R, signature.S)
}

Note: As will be described later, the key pair for the sender is generated each time.

For ED25519 public keys

ED25519 is also an algorithm for signing. Therefore, it cannot be used for encryption/decryption as well.
Also related to ED25519 is the X25519 key exchange algorithm.
Calculations based on the ED25519 key yield the X25519 key.
However, it is not possible to make an ED25519 key from a reversed X25519 key due to lossy transformation.

package ed25519

import (
    "crypto/ecdh"
    "crypto/ed25519"
    "crypto/sha512"
    "math/big"
)

func toX2519PrivateKey(edPrvKey *ed25519.PrivateKey) (*ecdh.PrivateKey, error) {
    key := sha512.Sum512(edPrvKey.Seed())
    return ecdh.X25519().NewPrivateKey(key[:32])
}

// p = 2^255 - 19
var p, _ = new(big.Int).SetString("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed", 16)
var one = big.NewInt(1)

func toX25519PublicKey(edPubKey *ed25519.PublicKey) (*ecdh.PublicKey, error) {
    // convert to big-endian
    bigEndianY := toReverse(*edPubKey)

    // turn off the first bit
    bigEndianY[0] &= 0b0111_1111

    y := new(big.Int).SetBytes(bigEndianY)
    numer := new(big.Int).Add(one, y)          // (1 + y)
    denomInv := y.ModInverse(y.Sub(one, y), p) // 1 / (1 - y)
    // u = (1 + y) / (1 - y)
    u := numer.Mod(numer.Mul(numer, denomInv), p)

    // convert to little-endian
    littleEndianU := make([]byte, 32)
    u.FillBytes(littleEndianU)
    littleEndianU = toReverse(littleEndianU)

    // create x25519 public key
    return ecdh.X25519().NewPublicKey(littleEndianU)
}

func toReverse(input []byte) []byte {
    length := len(input)
    output := make([]byte, length)
    for i, b := range input {
        output[length-i-1] = b
    }
    return output
}

Key exchange using X25519 is performed as follows.

package ed25519

import (
    "crypto/ecdh"
    "crypto/ed25519"
    "crypto/rand"
    "crypto/sha256"

    "github.com/yoshi389111/git-caesar/caesar/aes"
)

func Encrypt(otherPubKey *ed25519.PublicKey, message []byte) ([]byte, *ed25519.PublicKey, error) {

    // generate temporary key pair
    tempEdPubKey, tempEdPrvKey, err := ed25519.GenerateKey(rand.Reader)
    if err != nil {
        return nil, nil, err
    }

    // convert ed25519 public key to x25519 public key
    xOtherPubKey, err := toX25519PublicKey(otherPubKey)
    if err != nil {
        return nil, nil, err
    }

    // convert ed25519 prevate key to x25519 prevate key
    xPrvKey, err := toX2519PrivateKey(&tempEdPrvKey)
    if err != nil {
        return nil, nil, err
    }

    // key exchange
    sharedKey, err := exchangeKey(xPrvKey, xOtherPubKey)
    if err != nil {
        return nil, nil, err
    }

    // encrypt AES-256-CBC
    ciphertext, err := aes.Encrypt(sharedKey, message)
    if err != nil {
        return nil, nil, err
    }
    return ciphertext, &tempEdPubKey, nil
}

func Decrypt(prvKey *ed25519.PrivateKey, otherPubKey *ed25519.PublicKey, ciphertext []byte) ([]byte, error) {

    // convert ed25519 public key to x25519 public key
    xOtherPubKey, err := toX25519PublicKey(otherPubKey)
    if err != nil {
        return nil, err
    }

    // convert ed25519 prevate key to x25519 prevate key
    xPrvKey, err := toX2519PrivateKey(prvKey)
    if err != nil {
        return nil, err
    }

    // key exchange
    sharedKey, err := exchangeKey(xPrvKey, xOtherPubKey)
    if err != nil {
        return nil, err
    }

    // decrypt AES-256-CBC
    return aes.Decrypt(sharedKey, ciphertext)
}

func exchangeKey(xPrvKey *ecdh.PrivateKey, xPubKey *ecdh.PublicKey) ([]byte, error) {
    exchangedKey, err := xPrvKey.ECDH(xPubKey)
    if err != nil {
        return nil, err
    }
    sharedKey := sha256.Sum256(exchangedKey)
    return sharedKey[:], nil
}

func Sign(prvKey *ed25519.PrivateKey, message []byte) ([]byte, error) {
    hash := sha256.Sum256(message)
    sig := ed25519.Sign(*prvKey, hash[:])
    return sig, nil
}

func Verify(pubKey *ed25519.PublicKey, message, sig []byte) bool {
    hash := sha256.Sum256(message)
    return ed25519.Verify(*pubKey, hash[:], sig)
}

Using this exchanged key, encryption/decryption can be achieved in the same way as ECDSA.

Multiple public keys, different types of keys

GitHub and GitLab can have multiple public keys.

When working on multiple PCs/environments, using a single private key increases the possibility of leakage due to portability/copying.
In order to avoid that, we will generate a key pair in each environment and register the public key of it on GitHub, etc.

In this command, I wanted to make it possible for the receiver of the ciphertext to be able to decrypt it with any private key in such a case.

Also, it is normal for the other party's key algorithm to be different from your own key algorithm.

So I decided to encrypt it like this.
First, the shared key that encrypts the message body is generated with random numbers.

For RSA:
1. Encrypt the shared key using the recipient's RSA public key.
2. Pass the encrypted shared key to the other party
For ECDSA, ED25519:
1. Generate a one-time key pair.
2. Perform key exchange with the one-time private key and the recipient's public key.
3. Encrypt the shared key with the exchanged key.
4. Pass the encrypted shared key and the one-time public key to the other party

The container containing the encrypted shared key and the one-time public key is called an envelope.

The recipient selects the envelope that can be decrypted with own private key, restores the shared key, and decrypts the ciphertext.

Signature verification

In addition to encryption/decryption, this command also signs the "encrypted message body" with the sender's private key.
The recipient can check for spoofing and tampering by verifying the signature using her public key such as GitHub.

Signature verification using GitHub etc. is optional. Decryption only is also possible without signature verification.

Ciphertext file structure

The ciphertext generated by this command is a ZIP file containing the following two files.

caesar.json - a json file containing the following items
- signature data
- signer's public key
- version information
- list of envelopes
caesar.cipher - encrypted message body

Please note the following:

This ZIP file does not retain file name information before encryption. If necessary, the sender should inform the recipient of the file name separately.
This ZIP file does not hold information about where the sender's public key is located (GitHub account name, URL, etc.).
Encrypt only one file. If you encrypt multiple files at once, archive them in advance.

Installation

Requires go 1.20 or higher.

Execute the following commands to install and upgrade.

go install github.com/yoshi389111/git-caesar@latest

To uninstall, run the following command.

go clean -i github.com/yoshi389111/git-caesar

Usage

Usage:

  git-caesar [options]

Application Options:

  -h, --help                    print help and exit.
  -v, --version                 print version and exit.
  -u, --public=<target>         github account, url or file.
  -k, --private=<id_file>       ssh private key file.
  -i, --input=<input_file>      the path of the file to read. default: stdin
  -o, --output=<output_file>    the path of the file to write. default: stdout
  -d, --decrypt                 decryption mode.

-u specifies the location of the peer's public key. Get from https://github.com/USER_NAME.keys if the one specified looks like a GitHub username. If it starts with http: or https:, it will be fetched from the web. Otherwise, it will be determined as a file path. If you specify a file that looks like GitHub username, specify it with a path (e.g. -u ./octacat). Required for encryption. For decryption, perform signature verification if specified.
-k Specify your private key. If not specified, it searches ~/.ssh/id_ecdsa, ~/.ssh/id_ed25519, ~/.ssh/id_rsa in order and uses the first one found.
-i Input file. Plaintext file to be encrypted when encrypting. When decrypting, please specify the ciphertext file to be decrypted. If no options are specified, it reads from standard input.
-o output file. Outputs to standard output if no option is specified.
Specify -d for decrypt mode. Encrypted mode if not specified.

Example of use

Encrypt your file secret.txt for GitHub user octacat and save it as sceret.zip.

git-caesar -u octacat -i secret.txt -o secret.zip

In the same situation, the private key uses ~/.ssh/id_secret.

git-caesar -u octacat -i secret.txt -o secret.zip -k ~/.ssh/id_secret

Decrypt GitLab user tanuki's file secret.zip and save it as sceret.txt.

git-caesar -d -u https://gitlab.com/tanuki.keys -i secret.zip -o secret.txt

Same situation, no signature verification.

git-caesar -d -i secret.zip -o secret.txt

GitHub Repository

The GitHub repository is below.

https://github.com/yoshi389111/git-caesar

Special icons for social accounts on GitHub

SATO, Yoshiyuki — Sat, 06 May 2023 12:12:27 +0000

You can have up to 4 social account links on your GitHub profile.

Follow the steps below for the settings.
Your avatar on the top right of GitHub → settings → "Public profile" → "Social accounts"

https://github.blog/changelog/2023-02-02-add-more-social-links-to-your-user-profile/

You can now add up to 4 links to any social accounts to your user profile, with special support for popular platforms.

It states that it has "special support for popular platforms".
For example, if you register a Twitter URL, the chain icon will replace the Twitter icon.

Specifically, I checked what platforms are supported.
The checking method is simply looking at the HTML source.

If you have any of the following social accounts, I recommend registering them on GitHub (up to 4).

As of 2023-05-06, 9 social accounts seem to be supported.

Added on 2023-10-14: The npm account logo has been added and it seems to be compatible with 10 types of social accounts.

Added on 2025-03-01: The bluesky account logo has been added.

X (twitter)

Regex:

^https://(?:www\.)?(?:twitter|x)\.com/([^/?]+)/?$

Test URL:

https://twitter.com/test

facebook

Regex:

^https://(?:[^.]+\.)?facebook\.com/(?:[^/?]+/?|profile\.php\?id=\d+)$

Test URL:

https://facebook.com/test

instagram

Regex:

^https://(www\.)?instagram\.com/[^/?]+/?$

Test URL:

https://instagram.com/test

Regex:

^https://(?:www\.)?linkedin\.com/(?:in|company)/[^/?]+/?$

Test URL:

https://linkedin.com/in/test

Regex:

^https://(?:www\.)?reddit\.com/u(?:ser)?/([^/?]+)/?$

Test URL:

https://reddit.com/u/test

twitch

Regex:

^https://(?:www\.)?twitch\.tv/[^/?]+/?$

Test URL:

https://twitch.tv/test

youtube

Regex:

^https://(?:www\.)?youtube\.com/(user|c)/[^/?]+/?$
^https://(?:www\.)?youtube\.com/channel/[a-zA-Z0-9_-]{24}/?$
^https://(?:www\.)?youtube\.com/@[^/?]+/?$

Test URL:

https://youtube.com/user/test

mastodon

I don't know the specific pattern, but Mastodon seems to be supported.

Test URL:

https://mastodon.social/@test

hometown

hometown seems to be a SNS that forked mastodon.

Test URL:

https://rage.love/@test

I created a test URL from the server list on the following site.

https://github.com/hometown-fork/hometown/wiki/Hometown-servers

The icon looks the same as the mastodon.

npm

Added on 2023-10-14.

Regex:

^https://(?:www\.)?npmjs\.com/~([^/?]+)/?$

Test URL:

https://npmjs.com/~test

bluesky

Added on 2025-03-01.

Regex:

^https://bsky\.app/profile/([^@/]+)/?$

Test URL:

https://bsky.app/profile/test

Check number of CPUs

SATO, Yoshiyuki — Sat, 06 May 2023 00:22:39 +0000

Check number of CPUs in Linux

I wanted to know the number of CPUs in my Linux environment. The following Japanese version of the page was helpful.

物理 CPU、CPU コア、および論理 CPU の数を確認する

The corresponding English page looks like this:

How to find the number of physical cpus, cpu cores, and logical cpus

Number of physical CPUs

Some machines have multiple physical CPUs.

fgrep 'physical id' /proc/cpuinfo | sort -u | wc -l

Number of CPU cores

Some modern CPUs have multiple cores on a single physical CPU.

fgrep 'cpu cores' /proc/cpuinfo | sort -u | sed 's/.*: //'

Number of logical processors

Modern CPUs can do multiple things with a single core using features like hyper-threading.

Therefore, the number of logical processors can be greater than the number of physical CPUs times the number of cores.

fgrep 'processor' /proc/cpuinfo | wc -l

Simple shell script

Assuming all physical CPUs have the same number of cores, and hyper-threading as well, what would it look like?

#!/bin/bash

P_CPU=$( fgrep 'physical id' /proc/cpuinfo | sort -u | wc -l )
CORES=$( fgrep 'cpu cores' /proc/cpuinfo | sort -u | sed 's/.*: //' )
L_PRC=$( fgrep 'processor' /proc/cpuinfo | wc -l )
H_TRD=$(( L_PRC /  P_CPU / CORES ))

echo -n "${L_PRC} processer" ; [ "${L_PRC}" -ne 1 ] && echo -n "s"
echo -n " = ${P_CPU} socket" ; [ "${P_CPU}" -ne 1 ] && echo -n "s"
echo -n " x ${CORES} core"   ; [ "${CORES}" -ne 1 ] && echo -n "s"
echo -n " x ${H_TRD} thread" ; [ "${H_TRD}" -ne 1 ] && echo -n "s"
echo

$ cpucore.sh
8 processers = 1 socket x 4 cores x 2 threads

lscpu command

As I learned later, there seems to be a command called lscpu.

$ lscpu
Architecture:                    x86_64
CPU op-mode(s):                  32-bit, 64-bit
Byte Order:                      Little Endian
Address sizes:                   39 bits physical, 48 bits virtual
CPU(s):                          8
On-line CPU(s) list:             0-7
Thread(s) per core:              2
Core(s) per socket:              4
Socket(s):                       1
Vendor ID:                       GenuineIntel
CPU family:                      6
Model:                           142
Model name:                      Intel(R) Core(TM) i5-8250U CPU @ 1.60GHz
Stepping:                        10
CPU MHz:                         1799.998
BogoMIPS:                        3599.99
Virtualization:                  VT-x
Hypervisor vendor:               Microsoft
Virtualization type:             full
L1d cache:                       128 KiB
L1i cache:                       128 KiB
L2 cache:                        1 MiB
L3 cache:                        6 MiB
...Omitted below

I think the following will be the same information.

Thread(s) per core: 2
Core(s) per socket: 4
Socket(s): 1

Check number of CPUs in Windows

On Windows, it seems that you can check the number of CPUs in the same way as above with the following API.

Win32_Processor class

It seems that C ++ and C #, as well as PowerShell and VB can be acquired.

For the time being, in the case of VBS, I think that it will be as follows.

Option Explicit

Dim locator, resultSet, processor
Dim nSocket, nCore, nThread, totalThread
Dim msg

nSocket = 0
totalThread = 0

Set locator = WScript.CreateObject("WbemScripting.SWbemLocator")
Set resultSet = locator.ConnectServer.ExecQuery("SELECT * FROM Win32_Processor")
nSocket = resultSet.count
For Each processor In resultSet
  nCore = processor.NumberOfCores
  nThread= processor.NumberOfLogicalProcessors / processor.NumberOfCores
  totalThread= totalThread + processor.NumberOfLogicalProcessors
Next

msg = totalThread& " processer"
If 1 < totalThread Then
  msg = msg & "s"
End If

msg = msg & " = " & nSocket & " socket"
If 1 < nSocket Then
  msg = msg & "s"
End If

msg = msg & " x " & nCore & " core"
If 1 < nCore Then
  msg = msg & "s"
End If

msg = msg & " x " & nThread& " thread"
If 1 < nThread Then
  msg = msg & "s"
End If

WScript.Echo msg

Show ERRNO and Value

SATO, Yoshiyuki — Fri, 05 May 2023 05:55:17 +0000

I think there are times when I want to know the value of ERRNO when I build a program, or when I want to know the error message corresponding to the value, such as an error message of some command.
At times like that, I check with a simple shell script I made N years ago.

I don't think about difficult things such as whether it works in any environment or whether all errno can be checked (just think about it when it doesn't work).
For the time being, I moved in an environment where gcc is installed in Linux.
It just grep the include file for C language.

`errno.sh`

The created errno.sh script is as follows.

#!/bin/bash

if [[ $# -ne 1 || "$1" = "-h" || "$1" = "--help" ]]; then
  echo "Usage: $(basename $0) { ERROR_NUMBER | ERROR_NAME }" >&2
  exit 1

elif [[ ! ( "$1" =~ ^E[A-Z0-9]+$ || "$1" =~ ^[1-9][0-9]*$ ) ]]; then
  echo "illegal argument." >&2
  exit 1

elif ! find /usr/include -name 'errno*.h' -print0 |
  xargs -0 -r grep -Eh \
    -e "^\\s*#\\s*define\\s+E[A-Z0-9]+\\s+$1\\>" \
    -e "^\\s*#\\s*define\\s+$1\\s+[1-9][0-9]*\\>" \
    -e "^\\s*#\\s*define\\s+$1\\s+E[A-Z0-9]+\\>"
then
  echo "errno not found($1)." >&2
  exit 1
fi

Some examples are shown below.

$ errno.sh
Usage: errno.sh { ERROR_NUMBER | ERROR_NAME }
$ errno.sh EIO
#define EIO              5      /* I/O error */
$ errno.sh 125
#define ECANCELED       125     /* Operation Canceled */

note

ERRNO range

$ for N in $(seq 1 140) ; do errno.sh $N ; done
#define EPERM            1      /* Operation not permitted */
#define ENOENT           2      /* No such file or directory */
#define ESRCH            3      /* No such process */
#define EINTR            4      /* Interrupted system call */
#define EIO              5      /* I/O error */
#define ENXIO            6      /* No such device or address */
#define E2BIG            7      /* Argument list too long */
#define ENOEXEC          8      /* Exec format error */
#define EBADF            9      /* Bad file number */
#define ECHILD          10      /* No child processes */
#define EAGAIN          11      /* Try again */
#define ENOMEM          12      /* Out of memory */
#define EACCES          13      /* Permission denied */
#define EFAULT          14      /* Bad address */
#define ENOTBLK         15      /* Block device required */
#define EBUSY           16      /* Device or resource busy */
#define EEXIST          17      /* File exists */
#define EXDEV           18      /* Cross-device link */
#define ENODEV          19      /* No such device */
#define ENOTDIR         20      /* Not a directory */
#define EISDIR          21      /* Is a directory */
#define EINVAL          22      /* Invalid argument */
#define ENFILE          23      /* File table overflow */
#define EMFILE          24      /* Too many open files */
#define ENOTTY          25      /* Not a typewriter */
#define ETXTBSY         26      /* Text file busy */
#define EFBIG           27      /* File too large */
#define ENOSPC          28      /* No space left on device */
#define ESPIPE          29      /* Illegal seek */
#define EROFS           30      /* Read-only file system */
#define EMLINK          31      /* Too many links */
#define EPIPE           32      /* Broken pipe */
#define EDOM            33      /* Math argument out of domain of func */
# define EDOM   33      /* Math argument out of domain of function.  */
#define ERANGE          34      /* Math result not representable */
# define ERANGE 34      /* Math result not representable.  */
#define EDEADLK         35      /* Resource deadlock would occur */
#define ENAMETOOLONG    36      /* File name too long */
#define ENOLCK          37      /* No record locks available */
#define ENOSYS          38      /* Function not implemented */
#define ENOTEMPTY       39      /* Directory not empty */
#define ELOOP           40      /* Too many symbolic links encountered */
errno not found(41).
#define ENOMSG          42      /* No message of desired type */
#define EIDRM           43      /* Identifier removed */
#define ECHRNG          44      /* Channel number out of range */
#define EL2NSYNC        45      /* Level 2 not synchronized */
#define EL3HLT          46      /* Level 3 halted */
#define EL3RST          47      /* Level 3 reset */
#define ELNRNG          48      /* Link number out of range */
#define EUNATCH         49      /* Protocol driver not attached */
#define ENOCSI          50      /* No CSI structure available */
#define EL2HLT          51      /* Level 2 halted */
#define EBADE           52      /* Invalid exchange */
#define EBADR           53      /* Invalid request descriptor */
#define EXFULL          54      /* Exchange full */
#define ENOANO          55      /* No anode */
#define EBADRQC         56      /* Invalid request code */
#define EBADSLT         57      /* Invalid slot */
errno not found(58).
#define EBFONT          59      /* Bad font file format */
#define ENOSTR          60      /* Device not a stream */
#define ENODATA         61      /* No data available */
#define ETIME           62      /* Timer expired */
#define ENOSR           63      /* Out of streams resources */
#define ENONET          64      /* Machine is not on the network */
#define ENOPKG          65      /* Package not installed */
#define EREMOTE         66      /* Object is remote */
#define ENOLINK         67      /* Link has been severed */
#define EADV            68      /* Advertise error */
#define ESRMNT          69      /* Srmount error */
#define ECOMM           70      /* Communication error on send */
#define EPROTO          71      /* Protocol error */
#define EMULTIHOP       72      /* Multihop attempted */
#define EDOTDOT         73      /* RFS specific error */
#define EBADMSG         74      /* Not a data message */
#define EOVERFLOW       75      /* Value too large for defined data type */
#define ENOTUNIQ        76      /* Name not unique on network */
#define EBADFD          77      /* File descriptor in bad state */
#define EREMCHG         78      /* Remote address changed */
#define ELIBACC         79      /* Can not access a needed shared library */
#define ELIBBAD         80      /* Accessing a corrupted shared library */
#define ELIBSCN         81      /* .lib section in a.out corrupted */
#define ELIBMAX         82      /* Attempting to link in too many shared libraries */
#define ELIBEXEC        83      /* Cannot exec a shared library directly */
#define EILSEQ          84      /* Illegal byte sequence */
# define EILSEQ 84      /* Illegal byte sequence.  */
#define ERESTART        85      /* Interrupted system call should be restarted */
#define ESTRPIPE        86      /* Streams pipe error */
#define EUSERS          87      /* Too many users */
#define ENOTSOCK        88      /* Socket operation on non-socket */
#define EDESTADDRREQ    89      /* Destination address required */
#define EMSGSIZE        90      /* Message too long */
#define EPROTOTYPE      91      /* Protocol wrong type for socket */
#define ENOPROTOOPT     92      /* Protocol not available */
#define EPROTONOSUPPORT 93      /* Protocol not supported */
#define ESOCKTNOSUPPORT 94      /* Socket type not supported */
#define EOPNOTSUPP      95      /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT    96      /* Protocol family not supported */
#define EAFNOSUPPORT    97      /* Address family not supported by protocol */
#define EADDRINUSE      98      /* Address already in use */
#define EADDRNOTAVAIL   99      /* Cannot assign requested address */
#define ENETDOWN        100     /* Network is down */
#define ENETUNREACH     101     /* Network is unreachable */
#define ENETRESET       102     /* Network dropped connection because of reset */
#define ECONNABORTED    103     /* Software caused connection abort */
#define ECONNRESET      104     /* Connection reset by peer */
#define ENOBUFS         105     /* No buffer space available */
#define EISCONN         106     /* Transport endpoint is already connected */
#define ENOTCONN        107     /* Transport endpoint is not connected */
#define ESHUTDOWN       108     /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS    109     /* Too many references: cannot splice */
#define ETIMEDOUT       110     /* Connection timed out */
#define ECONNREFUSED    111     /* Connection refused */
#define EHOSTDOWN       112     /* Host is down */
#define EHOSTUNREACH    113     /* No route to host */
#define EALREADY        114     /* Operation already in progress */
#define EINPROGRESS     115     /* Operation now in progress */
#define ESTALE          116     /* Stale file handle */
#define EUCLEAN         117     /* Structure needs cleaning */
#define ENOTNAM         118     /* Not a XENIX named type file */
#define ENAVAIL         119     /* No XENIX semaphores available */
#define EISNAM          120     /* Is a named type file */
#define EREMOTEIO       121     /* Remote I/O error */
#define EDQUOT          122     /* Quota exceeded */
#define ENOMEDIUM       123     /* No medium found */
#define EMEDIUMTYPE     124     /* Wrong medium type */
#define ECANCELED       125     /* Operation Canceled */
#  define ECANCELED     125
#define ENOKEY          126     /* Required key not available */
#define EKEYEXPIRED     127     /* Key has expired */
#define EKEYREVOKED     128     /* Key has been revoked */
#define EKEYREJECTED    129     /* Key was rejected by service */
#define EOWNERDEAD      130     /* Owner died */
#  define EOWNERDEAD            130
#define ENOTRECOVERABLE 131     /* State not recoverable */
#  define ENOTRECOVERABLE       131
#define ERFKILL         132     /* Operation not possible due to RF-kill */
#  define ERFKILL               132
#define EHWPOISON       133     /* Memory page has hardware error */
#  define EHWPOISON             133
errno not found(134).
errno not found(135).
errno not found(136).
errno not found(137).
errno not found(138).
errno not found(139).
errno not found(140).
$

ERRNO with multiple names

$ errno.sh EDEADLK
#define EDEADLK         35      /* Resource deadlock would occur */
#define EDEADLOCK       EDEADLK
$ errno.sh EAGAIN
#define EAGAIN          11      /* Try again */
#define EWOULDBLOCK     EAGAIN  /* Operation would block */
$ errno.sh EOPNOTSUPP
#define EOPNOTSUPP      95      /* Operation not supported on transport endpoint */
# define ENOTSUP EOPNOTSUPP

I made a VSCode extension: "Visible Whitespace"

SATO, Yoshiyuki — Sat, 29 Apr 2023 20:57:00 +0000

Last month, I made a VSCode extension and learned about VSCode Decorators for it.
At that time, I wanted to create another VSCode extension even if I used a certain function of Decorator.

And what I made is "Visible Whitespace".
This is an extension that makes whitespace visible.

A similar extension already exists.
However, in order to output the results of learning, I decided to make one myself.

This extension is published on the marketplace.

marketplace: Visible Whitespace

The source code is on GitHub.

yoshi389111 / visible-whitespace

A VS Code extension that makes whitespace visible.

Visible Whitespace

An extension that makes whitespace visible.

Features

This extension visually displays the following whitespace characters:

H-TAB (U+0009) - Disabled by default.
LF (U+000A) or CRLF (U+000D + U+000A)
Space (U+0020) - Disabled by default.
No-Break Space (U+00A0)
Ideographic Space (U+3000)
other whitespace (U+180E, U+2000-U+200A, U+202F, U+205F, U+2800)
EOF

Extension Settings

visibleWhitespace.enabledLanguageIds: A list of languageIds for which this extension should be enabled. If empty, it will be enabled for all languageIds. e.g. [ "plaintext", "markdown" ]
visibleWhitespace.updateDelay: Delay time in milliseconds before updating. Smaller values will color faster, but will increase processing cost.
visibleWhitespace.overlayColor: Specify the color of the overlay text. eg. #RRGGBB, rgb(R,G,B) or rgba(R,G,B,A) format.
visibleWhitespace.htab.enable: Enables making horizontal tabs visible. (default: false)
visibleWhitespace.htab.text: Text to overlay on horizontal tabs.
visibleWhitespace.newLine.enable: Enables making new line visible.
visibleWhitespace.newLine.lf: Text of LF.
visibleWhitespace.newLine.crLf: Text of CRLF.
visibleWhitespace.newLine.color: Color…

View on GitHub

How to install

Download it from the marketplace or search for Visible Whitespace in VSCode Extensions and install it.

Features

This extension visually displays the following whitespace characters:

H-TAB (U+0009) - Disabled by default.
LF (U+000A) or CRLF (U+000D + U+000A)
Space (U+0020) - Disabled by default.
No-Break Space (U+00A0)
Ideographic Space (U+3000)
other whitespace (U+180E, U+2000-U+200A, U+202F, U+205F, U+2800)
EOF

Extension Settings

visibleWhitespace.enabledLanguageIds: A list of languageIds for which this extension should be enabled. If empty, it will be enabled for all languageIds. e.g. [ "plaintext", "markdown" ]
visibleWhitespace.updateDelay: Delay time in milliseconds before updating. Smaller values will color faster, but will increase processing cost.
visibleWhitespace.overlayColor: Specify the color of the overlay text. eg. #RRGGBB, rgb(R,G,B) or rgba(R,G,B,A) format.
visibleWhitespace.htab.enable: Enables making horizontal tabs visible. (default: false)
visibleWhitespace.htab.text: Text to overlay on horizontal tabs.
visibleWhitespace.newLine.enable: Enables making new line visible.
visibleWhitespace.newLine.lf: Text of LF.
visibleWhitespace.newLine.crLf: Text of CRLF.
visibleWhitespace.newLine.color: Color of text that represents new line. eg. #RRGGBB, rgb(R,G,B) or rgba(R,G,B,A) format.
visibleWhitespace.space.enable: Enables making spaces visible. (default: false)
visibleWhitespace.space.render: Controls how the editor should render spaces. (default: "all")
visibleWhitespace.space.text: Text to overlay on spaces.
visibleWhitespace.nbsp.enable: Enables making no-break spaces visible.
visibleWhitespace.nbsp.text: Text to overlay on no-break spaces.
visibleWhitespace.widespace.enable: Enables making wide-spaces visible.
visibleWhitespace.widespace.text: Text to overlay on wide-spaces.
visibleWhitespace.other.enable: Enables making other whitespaces visible.
visibleWhitespace.other.borderColor: Border color of other whitespace. eg. #RRGGBB, rgb(R,G,B) or rgba(R,G,B,A) format.
visibleWhitespace.eof.enable: Enables making EOF visible.
visibleWhitespace.eof.text: Text of EOF.
visibleWhitespace.eof.color: Color of text that represents EOF. eg. #RRGGBB, rgb(R,G,B) or rgba(R,G,B,A) format.

The default for visibleWhitespace.htab.enable and visibleWhitespace.space.enable is disable because the standard editor.renderWhitespace is used.

If you want to use this extension instead of the standard editor.renderWhitespace, set "editor.renderWhitespace": "none" and set the above definition to true.

Sites used as reference for creation

Miscellaneous Notes

overlay characters

I didn't understand it just by looking at the API specifications, but I learned that you can use character decorations to overlay characters.

If you specify the content in before and "0" in width, it will be displayed overlapping.

    const regex = /\u3000/g;
    const decorationType = vscode.window.createTextEditorDecorationType({
        rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
        before: {
            contentText: "\u2395",
            width: "0",
            color: "rgb(127,127,127)",
        },
    });

This overlay feature made me want to make this extension.

Interference with other extensions

Originally, the newline code was displayed as a normal before.
In other words, you didn't set widht to "0".
However, when I used it in conjunction with some other extension, it behaved strangely.

Specifically, with this extension only, the cursor does not move behind the before code of the new line code.
However, when used with some extensions, the cursor was not positioned in front of the arrow of the new line code, and moved behind the arrow. .

Therefore, I specified width: "0" for the new line code and EOF just in case.

I have not been able to investigate what specific extensions were hit.

APL symbols, etc.

Currently, wide-spaces are displayed by overlapping squares by default.

The overlayed square "⎕" (U+2395) is a character called "APL Functional Symbol Quad" in Unicode, and it seems to be a symbol for functions in the APL language.

At first I was going to use "□" (U+25A1; "White Square").
However, this character is designed to be wide in fonts such as Japanese, but is designed to be narrow (small because it is square) in fonts such as English.
In East Asian Width, this character is treated as A (ambiguous).
That is, characters that may or may not be wide depending on the context in which they appear.
Therefore, I thought that it might not be displayed well depending on the setting.
So we use U+2395 above.
It's a character added in Unicode 3.0, so I think it's already displayable in most environments.

If there seems to be an environment where the APL symbol is not displayed well, please define to display it with a different character.

Similarly, No-Break Space is also an APL symbol. If this is also not displayed well, please define so that it is displayed with some suitable character.

If there are any other problems related to East Asian character widths, etc., please define them so that they are displayed with appropriate characters as well.

Text decoration border

Above, "other whitespaces" are marked with a vermilion border.
However, if these characters are consecutive, the border range will join.

Why?

Display of before/after elements remains temporarily

When deleting the new line code, the arrow representing the new line code may remain for a moment.
Then it disappears after the display update delay time.

At that time, width: "0" was not specified for the new line code.
In that state, if you delete multiple lines at once, multiple arrows representing new line codes are displayed together for a moment immediately after deletion, and then disappear.

In my environment, after setting the display width of the newline code to width: "0", it doesn't bother me much.
If it bothers you, please turn off the new line code display.

Mixed new line code

Even if he opens a file with line endings mixed with LF and CRLF, VSCode seems to compensate for either when opening the file.
So, I don't think there is basically a case where new line codes are mixed on one editor.

Defining activationEvents

Initially, this extension did not narrow down the file type and set "activationEvents": ["*"], so when the extension was published (when the vsce publish command was executed), a warning was issued every time. I was.

I reread the documentation and found something called onStartupFinished.

This activation event is emitted and interested extensions will be activated some time after VS Code starts up. This is similar to the * activation event, but it will not slow down VS Code startup. Currently, this event is emitted after all the * activated extensions have finished activating.

* slows down the startup performance, but onStartupFinished is called after the startup process is finished, so I decided that the performance problem would disappear.

With or without BOM

For files with BOM, I wanted to place the BOM gutter icon on the first line.

However, it seems that VSCode cannot acquire the character code and the presence or absence of her BOM, so I gave up.

EOF range specification

The EOF range specifies a range of 0 characters after the last character of the document.
Feeling like the following.

            const eofPosition = editor.document.positionAt(text.length);
            const range = new vscode.Range(eofPosition, eofPosition);

Such specifications were also possible.

color specification format

There are some items in settings.json that let you specify colors.
There is no color in VSCode's definition type, so I'm trying to have it defined as a string.

If it is just string, it will be in free format, so we specify a regular expression for pattern in package.json to check the color specification format.

Currently, the following three patterns are allowed.

#RRGGBB format. RR/GG/BB are two hexadecimal digits
rgb(R,G,B) format. R/G/B ranges from 0 to 255. A cannot be specified
rgba(R,G,B,A) format. R/G/B ranges from 0 to 255. A is from 0 to 1, and the decimal point format is also possible (in fact, 1.999 etc. may also be specified)

No other formats are currently accepted.
This is because only one regular expression is specified in the pattern of package.json, so it is difficult to perform complicated checks.

Is it better to specify #RGB, #RRGGBBAA and hsv()?
Also, would it be better if rgb() could specify the alpha channel as well?

Japanese version of this document

Qiita: 全角スペース/改行/EOFとかを可視化するVSCode拡張機能を作ったよ

POng is Not pinG.

SATO, Yoshiyuki — Mon, 24 Apr 2023 14:06:28 +0000

I created the pong command in Go language.

See below for a run-time image.

This command was inspired by the existing awesome pong command.

That awesome pong command was created by kurehajime.

kurehajime / pong-command

pong is not ping. pong is CLI game.

pong-command

Pong-command is a CLI game.

POng is Not pinG.

How to use.

1. Download Win/Mac OSX/Linux binary

Download here. Windows,MacOSX,Linux,BSD binary

2. Move file or Add directory to PATH

Mac OSX / Linux :

Copy a file into /usr/local/bin

cp ./pong /usr/local/bin/pong

Windows :

Add directory to PATH Environment Variable

3. pong

Run command.

$./pong <IP Address>

Start game.


                                                                     006 - 000
--------------------------------------------------------------------------------








                                                                      1
                                                                        9   ||
                                                                          2 ||
  ||                                                                      . ||
  ||                                                                    1   ||
  ||                                                                  6
  ||                                                                8
                                                                  .
                                                                1
                                                              .
                                                            1


--------------------------------------------------------------------------------
EXIT : ESC KEY

... or install by 'go install'

go install github.com/kurehajime/pong-command/pong@latest

LICENSE

This software is released under the MIT License, see LICENSE.txt.

View on GitHub

In this pong command, the target hostname you enter will take the place of the ball.

Sounds like a great idea, doesn't it?

The key types for pong and ping are similar (O and I next to each other in QWERTY).
Therefore, I feel that it is similar to the key type correction effect of the sl command for the ls command.

Ubuntu manuals: sl(6)

If you thought the above article and command ideas were great, I encourage you to star the repository before reading the rest of the text.

When I saw this command, I thought, "Great idea."
However, at the same time, I thought, "Is there another possibility?"

So let's start by looking at the pong game and the ping command.

What is pong game?

It is a game like so-called table tennis (ping pong).
Various pong games have been created since recorded history.

Pong is a table tennis–themed twitch arcade sports video game, featuring simple two-dimensional graphics, manufactured by Atari and originally released in 1972. It was one of the earliest arcade video games; it was created by Allan Alcorn as a training exercise assigned to him by Atari co-founder Nolan Bushnell, but Bushnell and Atari co-founder Ted Dabney were surprised by the quality of Alcorn's work and decided to manufacture the game. Bushnell based the game's concept on an electronic ping-pong game included in the Magnavox Odyssey, the first home video game console. In response, Magnavox later sued Atari for patent infringement.

View on Wikipedia

It is common for two players to play against each other, or for users against computers.
There are paddles (or racquets) on the left and right (or top and bottom) of the screen, and players operate the paddles to hit the ball.

I think it is no exaggeration to say that it is probably the beginning of e-sports.

What is the ping command?

The ping command is a command that checks whether there is a response from a device with a specific IP address on the IP network.

The ping command is usually executed by specifying the target host (IP address or hostname).

The executed ping command will send an ICMP protocol echo request packet towards the target.
When the target host receives an ICMP echo request packet, it returns an echo reply packet to the source (some hosts do not respond due to settings, etc.).

If the target host is not on the same network, the gateway between networks will relay the echo request/reply packets. At that time, the TTL (Time To Live) value in the packet is decremented by 1, and if the result of the decrement is 0, the packet is not relayed and discarded.

The ping command records network reachability, response time, etc. by receiving or not returning an ICMP echo reply from the target host.

Depending on the execution environment and option specification, it sends and receives ICMP echo packets for a specified number of times or until the user stops (such as CTRL+C), and finally reports the result.

ping is a computer network administration software utility used to test the reachability of a host on an Internet Protocol (IP) network. It is available for virtually all operating systems that have networking capability, including most embedded network administration software.

View on Wikipedia

I created the pong command.

After examining the similarities and differences between the pong game and the ping command, I created the pong command.

When you run the pong command with a target host, the local host (on the far left of the screen) will send an ICMP ECHO packet.

On the target host (the paddle you control on the right), take the incoming ICMP ECHO packets and send them back to the host that sent them (the localhost on the far left).

However, the Gateway (the paddle on the left side of the screen, operated by the computer) in between, for whatever reason, always sends it back to the target host when it receives an ICMP ECHO packet.
So you need to send an ICMP ECHO packet back to the localhost while avoiding the Gateway.
When the Gateway sends back, the TTL is decremented, so send it back before the TTL runs out (by default the TTL starts from 64).

Also, if you send back many times, the network speed will gradually increase. be careful.

By default, the local host will send ICMP ECHO packets 4 times.
After the last packet has been received (or lost), or if the user has stopped, display packet response state statistics up to that point.

The starting method of this pong command is as follows.

pong [options] <destination>

The following can be specified as options.

Application Options:
  -h, --help                 print help and exit
  -v, --version              print version and exit
  -c, --count=<count>        stop after <count> replies (default: 4)
  -t, --ttl=<ttl>            define time to live (default: 64)
  -p, --padding=<pattern>    contents of padding byte

Arguments:
  <destination>:             dns name or ip address

The source code is on GitHub.

yoshi389111 / pong-is-not-ping

POng is Not pinG

Pong-is-not-Ping

This command is pong game.

POng is Not pinG.

Inspired by kurehajime/pong-command

Installation

go install github.com/yoshi389111/pong-is-not-ping/cmd/pong@latest

Usage

Usage:

  pong [options] <destination>

Options:

Application Options:
  -h, --help                 print help and exit
  -v, --version              print version and exit
  -c, --count=<count>        stop after <count> replies (default: 4)
  -t, --ttl=<ttl>            define time to live (default: 64)
  -p, --padding=<pattern>    contents of padding byte

Arguments:
  <destination>:             dns name or ip address

Copyright and License

This software is released under the MIT License.

View on GitHub

The Japanese version of this article is below.

Qiita: Go言語でpingコマンドっぽい、でもpingコマンドじゃないpongコマンドを作ってみた

I made a VSCode extension: "markdown-table-rainbow"

SATO, Yoshiyuki — Sat, 22 Apr 2023 05:03:28 +0000

Last month when I was writing Markdown, I thought it would be easier to understand if each column in the table had its own color, so I made a VSCode extension that colors the columns in the table.

Of course, I knew there were extensions to format Markdown tables, but I have a problem when:

If the table has very long items and formatting makes them too wide
When CKJ characters are used and formatting does not align well

As far as I know, I haven't found an extension with similar functionality.

This extension is published on the marketplace.

marketplace: markdown-table-rainbow

The source code is on GitHub.

yoshi389111 / vscode-md-table-rainbow

A VS Code extension that colorizes table columns in Markdown for clarity.

markdown-table-rainbow

An extension that colorizes table columns in Markdown for clarity.

Features

This extension colors by columns in markdown tables.

Extension Settings

You can use it without any setting. However, you can also change:

  // Delay time in milliseconds before updating colors.
  // Smaller values will color faster, but will increase processing cost.
  "markdownTableRainbow.updateDelay": 100,
  // An array of color strings (hex, rgba, rgb) for each column.
  // You can specify any number of colors. used cyclically.
  "markdownTableRainbow.colors": [
    "rgba(79,236,236,0.1)",
    "rgba(255,255,63,0.1)",
    "rgba(127,255,127,0.1)",
    "rgba(255,127,255,0.1)"
  ],
  // Cursor column color strings (hex, rgba, rgb).
  "markdownTableRainbow.cursorColor": "rgba(100,50,180,0.8)",

View on GitHub

How to install

Download it from the marketplace or search for markdown-table-rainbow in VSCode Extensions and install it.

Features

This extension colors by columns in markdown tables.

Also, when the cursor is on a table column, all columns at the same position as the corresponding column are colored.

Extension Settings

You can use it without any setting. However, you can also change:

  // Delay time in milliseconds before updating colors.
  // Smaller values will color faster, but will increase processing cost.
  "markdownTableRainbow.updateDelay": 100,
  // An array of color strings (hex, rgba, rgb) for each column.
  // You can specify any number of colors. used cyclically.
  "markdownTableRainbow.colors": [
    "rgba(79,236,236,0.1)",
    "rgba(255,255,63,0.1)",
    "rgba(127,255,127,0.1)",
    "rgba(255,127,255,0.1)"
  ],
  // Cursor column color strings (hex, rgba, rgb).
  "markdownTableRainbow.cursorColor": "rgba(100,50,180,0.8)",

markdownTableRainbow.updateDelay

Specifies the delay time in milliseconds before updating. When not specified, it operates as 100ms.

Smaller values will color faster, but will increase processing cost.

markdownTableRainbow.colors

Specifies a list (array) of background colors for each column in the table.
If not specified, the default color will be used.
Cycles through the specified list if the number of columns in the table is greater than the array length.

The colors that can be specified are as follows.

#RRGGBB
rgb(R, G, B)
rgba(R, G, B, A)

markdownTableRainbow.cursorColor

Specifies the color of the column at the same position as the cursor position.

The colors that can be specified are the same as markdownTableRainbow.colors.

Sites used as reference for creation

Miscellaneous Notes

Parsing Markdown

When I first came up with this extension, I thought I would have to use a library to parse the structure of Markdown.
However, when I checked some sources of extension functions for manipulating Markdown tables, I couldn't find any that used such a library.
So I decided to use regular expressions for table-like expressions, i.e. rows containing | at the beginning of a line and multiple | on the same line.

Lines starting with > are also included to account for tables within quoted blocks.

So, for example, if there is a Markdown table description inside a code block, it will be misidentified as a table as well. This is the intended behavior.

range to color

This time, the range of columns to be colored is inclusive of the leading | and not including the trailing |.

At first, I thought it would be better not to include both, but I found an article that says that depending on the type of markdown, colspan-like things can be written like | here is a two-column join ||.
Therefore, I thought that it would be difficult to understand if the column color was not displayed at all, so I put a | on one side.

I could have included either before or after, but for now I included the previous |.

About resource dispose

In the official sample code mentioned above, we only create an instance of vscode.TextEditorDecorationType, which is a definition for decoration, and do not do anything particularly post-processing.

But if you look at the source of vscode.TextEditorDecorationType there is a dispose() method.
It may not be a problem if I don't call it, but it bothers me so I called dispose() at the end.

Just register it with the instance of vscode.ExtensionContext that is passed when activate() is called, and it will be processed when it is no longer needed.

rangeBehavior

By default, the decoration range of VSCode is a specification that if you add a character immediately before or after it, the added character will also be included in the decoration range.

Specifically, the rangeBehavior specified in vscode.TextEditorDecorationType is OpenOpen by default.

In this extension, | in front of the column is included in the decoration range, but when a character is added before that, it is strange that the added character will be colored in the column behind it, so marked Closed.

Since the trailing | is not included in the decoration range, it is often better to input immediately after the decoration range (that is, before |) in the column color, so immediately after I left it as Open (the exception is when entering a new |, but in that case, I decided that rewriting after the delay would not be a problem).

Now specifies ClosedOpen as result.

Loading timing of setting items

At first, like the official sample, I looked at the config when activate() was called and generated a definition for vscode.TextEditorDecorationType.

However, with this, even if the user rewrites settings.json, it will continue to work with the old definition unless activate() is called again. And since it is not called normally, it will not be reflected unless you restart.

Therefore, vscode.workspace.onDidChangeConfiguration() detects the configuration change and recreates the vscode.TextEditorDecorationType object again.

By the way, vscode.TextEditorDecorationType is registered in context.subscriptions in order to dispose() at the end of processing.
It may not be such a problem, but it is annoying to keep unnecessary resources all the time, and if you change the configuration many times, it will be registered many times, so when you recreate it, Added processing to remove the previous object from context.subscriptions.

I'm not sure if this method is the best.

Checking config array values

In the case of items defined from the setting screen, even if they are of string type, for example, they can be checked with regular expressions (regular expressions can be specified in the pattern of the property definition in package.json).

However, this time, the background color is defined as an array type, and it is necessary to have it listed directly in settings.json, so the format check cannot be applied as it is.

Therefore, I detected the configuration change with vscode.workspace.onDidChangeConfiguration() mentioned above and applied a format check when recreating the resource.

At that time, I am currently preparing a long regular expression and checking whether it matches.
Actually, I feel that it would be better to divide it into several short regular expressions or check it with logic instead of doing everything with regular expressions (for example, if the value of R/G/B is 0 to 255 is easier to do with logic than with a regular expression). This is because I thought that the regular expression could be used in common if I checked the format with the definition (pattern) of package.json and checked both with regular expressions.
In the future, when I increase other patterns, I just copy the same value for both.

Therefore, the JavaScript regular expression is defined like new RegExp("RE") instead of /RE/ (the other one defines it as a string in package.json, so use the same format wanted).

How to get config

I saw a source that acquired the config as follows.

const config = vscode.workspace.getConfiguration('myExtension');
const updateDelay: number = config['updateDelay'] || 500;

This still works, but in this case the value returned by config[] is of the form any.

Looking at the API specifications, there is a method called get(), which seems to allow you to specify a generic type and specify a default value in the method. Of course, it is necessary to describe it with consistency between the definition and the code.

const config = vscode.workspace.getConfiguration('myExtension');
const updateDelay: number = config.get<number>('updateDelay', 500);

Filtering documents of interest

At first, I misunderstood, and if I registered onLanguage:markdown in activationEvents of package.json, I thought that the event would be notified only in Markdown, but apparently it is activated when a Markdown file is opened. Subsequent events seem to be notified regardless of document type.

So before processing the target editor we need to check if the document is target like this:

  if (editor.document.languageId !== 'markdown') {
    return;
  }

I thought this would be fine, but I thought it would be troublesome to have to modify both package.json and this logic if I wanted to process files other than markdown in the future.

It seems that context.extension.packageJSON can get the contents of the extension's package.json.
(Although he seems to be able to get other extensions with vscode.extensions.getExtension(). The key seems to be specified like "<publisher name>.<extension name>")

So I tried the following. The current situation is over spec.

    const onLanguages = (context.extension.packageJSON["activationEvents"] as string[])
        .filter(it => it.startsWith("onLanguage:"))
        .map(it => it.substring("onLanguage:".length));

    // ...

        if (!onLanguages.includes(editor.document.languageId)) {
            return;
        }

By the way, are there any languages other than markdown that should be supported?

Minimum version of VSCode

There is a place to describe the minimum version of VSCode that works in engines of package.json.

    "engines": {
        "vscode": "^1.76.0"
    },

This extension does not use any new features, so it should work even on very old versions.
However, I don't know how to test with older versions, so I specified the latest version at the time.

Is it usually the one that specifies the latest version?

Japanese version of this document

Qiita: Markdownのテーブルの列に色付けするVSCode拡張機能を作ったよ