Custom File Colorer - In AWK

#!/usr/bin/awk -f

  ######################################################################
 ######################################################################
## Author: Adam Michael Danischewski 
## GitHub: https://github.com/AdamDanischewski/scriptsandoneliners
## Created Date: 2019-11-12
## Name: colorfiles.awk
## Version: v0.00
## Last Modified: 2019-11-12
## Issues: If you find any issues emai1 me at <my first name> (dot) 
##         <my last name> (at) gmail (dot) com. 
##
## Requirements: awk 
## 
## Allows the user to fine tune and customize their color scheme for 
## files. LS_COLORS only allows for a small subset of file types. This 
## script allows specific colors for all files and can be utilized in 
## pipelines to color output after processing with tools that do not 
## have a color option. 
## 
## This script includes a color template that can be applied to 
## pipelines on the command line or to replace coloring features 
## of shell utilities. Edit/hack to your preference. 
## 
## This program 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.  
##
## Released under Creative Commons License: CC BY-SA 4.0
## https://creativecommons.org/licenses/by-sa/4.0/
 ######################################################################
  ######################################################################

function init_colormap() {
 colormap["pdf"]="108;107;21"
 startcolor="\033[38;2;"         ## TrueColor RGB triplet prefix 
 endcolor="\033[0m"
 colormap["jpg"]="0;85;0"  
 colormap["gif"]=colormap["jpg"] ## Grouping images, change as you wish.
 colormap["png"]=colormap["jpg"]
 colormap["jpeg"]=colormap["jpg"] 
 colormap["jpe"]=colormap["jpg"] ## JFIF
 colormap["blend"]="251;143;21"
 colormap["mp3"]="157;0;193"
 colormap["bsh"]="85;229;0"
 colormap["awk"]=colormap["bsh"]
 colormap["php"]=colormap["bsh"]
 colormap["js"]=colormap["bsh"]
 colormap["pl"]=colormap["bsh"]
 colormap["py"]=colormap["bsh"]
 colormap["vtt"]="0;85;157"  
 colormap["tex"]="0;0;229"  
 colormap["nzb"]="85;229;0"  
 colormap["deb"]="193;12;199"  
 colormap["txt"]="215;215;21"  
 colormap["mp4"]="85;0;193"  
 colormap["log"]="193;85;12"  
 colormap["c"]="0;121;229"  
 colormap["cc"]=colormap["c"]
 colormap["cpp"]=colormap["c"]
 colormap["h"]=colormap["c"]
 colormap["avi"]=colormap["mp4"]
 colormap["mov"]=colormap["mp4"]
 colormap["mkv"]=colormap["mp4"] 
 colormap["webm"]=colormap["mp4"] 
 colormap["html"]="157;0;193"
 colormap["css"]=colormap["html"]
 colormap["pdf"]="229;85;0"
 colormap["dir"]="0;157;229"    ## Directories - ending in / 
 colormap["links"]="251;22;143" ## Symbolic links - ending in @
 colormap["part"]="157;0;85"
 colormap["tar"]="229;0;193"
 colormap["tar.gz"]=colormap["tar"]
 colormap["tgz"]=colormap["tar"]
 colormap["tar.xz"]=colormap["tar"]
 colormap["tar.bz2"]=colormap["tar"]
 colormap["xz"]="229;0;85"
 colormap["gz"]=colormap["xz"]
 colormap["7z"]=colormap["xz"]
 colormap["iso"]=colormap["xz"]
 colormap["rar"]=colormap["xz"]
 colormap["par2"]=colormap["xz"]
 colormap["bz2"]=colormap["xz"]
 colormap["zip"]=colormap["xz"]
 colormap["kgb"]=colormap["xz"] # Future standard compression (PAQ)
 return
} 

function wrap_color(s) { 
 if (tolower(s) ~ /\.jpg[*]?$/) { 
  selc=colormap["jpg"]
 } else if (tolower(s) ~ /\.jpe[*]?$/) { 
  selc=colormap["jpe"]  
 } else if (tolower(s) ~ /\.gif[*]?$/) { 
  selc=colormap["gif"]  
 } else if (tolower(s) ~ /\.tar[*]?$/)    { 
  selc=colormap["tar"]  
 } else if (tolower(s) ~ /\.tar\.gz[*]?$/) { 
  ## Make sure these are before their respective 
  ## compression conditionals to avoid tar's 
  ## from being treated as simply compressed. 
  selc=colormap["tar.gz"]  
 } else if (tolower(s) ~ /\.tar.bz2[*]?$/)  { 
  selc=colormap["tar.bz2"]  
 } else if (tolower(s) ~ /\.tar.xz[*]?$/)  { 
  selc=colormap["tar.xz"]  
 } else if (tolower(s) ~ /\.tgz[*]?$/)  { 
  selc=colormap["tgz"]  
 } else if (tolower(s) ~ /\.jpeg[*]?$/) { 
  selc=colormap["jpeg"]  
 } else if (tolower(s) ~ /\.png[*]?$/)   { 
  selc=colormap["png"]               
 } else if (tolower(s) ~ /\.mp4[*]?$/)   { 
  selc=colormap["mp4"]              
 } else if (tolower(s) ~ /\.rar[*]?$/)   { 
  selc=colormap["rar"]         
 } else if (tolower(s) ~ /\.par2[*]?$/)   { 
  selc=colormap["par2"]         
 } else if (tolower(s) ~ /\.log[*]?$/)   { 
  selc=colormap["log"]         
 } else if (tolower(s) ~ /\.mp3[*]?$/)   { 
  selc=colormap["mp3"]         
 } else if (tolower(s) ~ /\.deb[*]?$/)   { 
  selc=colormap["deb"]  
 } else if (tolower(s) ~ /\.mov[*]?$/)   { 
  selc=colormap["mov"]  
 } else if (tolower(s) ~ /\.bsh[*]?$/)   { 
  selc=colormap["bsh"]  
 } else if (tolower(s) ~ /\.mkv[*]?$/)   { 
  selc=colormap["mkv"]  
 } else if (tolower(s) ~ /\.pdf[*]?$/)   { 
  selc=colormap["pdf"]  
 } else if (tolower(s) ~ /\.c[*]?$/)   { 
  selc=colormap["c"]  
 } else if (tolower(s) ~ /\.cpp[*]?$/)   { 
  selc=colormap["cpp"]  
 } else if (tolower(s) ~ /\.cc[*]?$/)   { 
  selc=colormap["cc"]  
 } else if (tolower(s) ~ /\.h[*]?$/)   { 
  selc=colormap["h"]  
 } else if (tolower(s) ~ /\.txt[*]?$/)   { 
  selc=colormap["txt"]  
 } else if (tolower(s) ~ /\.vtt[*]?$/)   { 
  selc=colormap["vtt"]  
 } else if (tolower(s) ~ /\.tex[*]?$/)   { 
  selc=colormap["tex"]  
 } else if (tolower(s) ~ /\.nzb[*]?$/)  { 
  selc=colormap["nzb"]  
 } else if (tolower(s) ~ /\.bz2[*]?$/)  { 
  selc=colormap["bz2"]  
 } else if (tolower(s) ~ /\.iso[*]?$/)  { 
  selc=colormap["iso"]  
 } else if (tolower(s) ~ /\.html[*]?$/)  { 
  selc=colormap["html"]  
 } else if (tolower(s) ~ /\.css[*]?$/)  { 
  selc=colormap["css"]  
 } else if (tolower(s) ~ /@$/)  { 
  selc=colormap["links"]  
 } else if (tolower(s) ~ /\.webm[*]?$/)  { 
  selc=colormap["webm"]  
 } else if (tolower(s) ~ /\.awk[*]?$/)    { 
  selc=colormap["awk"]  
 } else if (tolower(s) ~ /\.php[*]?$/)    { 
  selc=colormap["php"]  
 } else if (tolower(s) ~ /\.js[*]?$/)    { 
  selc=colormap["js"]  
 } else if (tolower(s) ~ /\.pl[*]?$/)    { 
  selc=colormap["pl"]  
 } else if (tolower(s) ~ /\.py[*]?$/)    { 
  selc=colormap["py"]  
 } else if (tolower(s) ~ /\.part[*]?$/)    { 
  selc=colormap["part"]  
 } else if (tolower(s) ~ /\.kgb[*]?$/)    { 
  selc=colormap["kgb"]  
 } else if (tolower(s) ~ /\.xz[*]?$/)  { 
  selc=colormap["xz"]  
 } else if (tolower(s) ~ /\.7z[*]?$/)  { 
  selc=colormap["7z"]  
 } else if (tolower(s) ~ /\.gz[*]?$/)  { 
  selc=colormap["gz"]  
 } else if (tolower(s) ~ /\.zip[*]?$/)  { 
  selc=colormap["zip"]  
 } else if (tolower(s) ~ /\/$/)  { 
  selc=colormap["dir"]  
 }
 else { 
  return s
 }  
 return (startcolor selc "m" s endcolor)
}

function usage() {
 usage_str=("\nUsage: /bin/ls -f1 | colorfiles.awk \n\n \
   Options: \n\
             -?    Help.\n\n\
Note: Make sure colors are not already present- you can sed the input.\n\
      Eg. $> ls --color| sed 's/\\x1B[[0-9;]\\+[A-Za-z]//g' |colorfiles.awk\n\
          $> alias colorfiles='sed \"s/\x1B[[0-9;]\\+[A-Za-z]//g\"|colorfiles.awk'\n\
          $> alias lsd='find \"$(pwd)\" -maxdepth 1 -type d -printf \"%T@\t%Tc %f/\\n\" 2>/dev/null|sort -n|cut -f 2-|tail -50|colorfiles'\n\
          $> alias lsf='find \"$(pwd)\" -maxdepth 1 -type f -printf \"%T@\t%Tc %f\\n\" 2>/dev/null|sort -n|cut -f 2-|tail -50|colorfiles'\n\
          $> alias ls='/bin/ls -F -f1|colorfiles'\n")
 return usage_str
}

BEGIN {if(v_opt1=="-?"){print usage();exit 1;}else{init_colormap();};}

## Main
{
 print wrap_color($0) 
}

Get the latest on GitHub.

Bash Implementation of B.R. Heaps' Permutation Algorithm

#!/bin/bash 

  ######################################################################
 ######################################################################
## Author: Adam Michael Danischewski 
## GitHub: https://github.com/AdamDanischewski/hpermutate
## Created Date: 2019-11-08
## Name: hpermutate.bsh 
## Version: v0.00
## Last Modified: 2019-11-08
## Issues: If you find any issues emai1 me at <my first name> (dot) 
##         <my last name> (at) gmail (dot) com. 
## 
## This is a Bash implementation of Heap's algorithm which generates all 
## possible permutations of n objects, as first proposed by B. R. Heap 
## in 1963. Speed is reasonable for a recursive shell script. 
##
## This program 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.  
##
## Released under Creative Commons License: CC BY-SA 4.0
## https://creativecommons.org/licenses/by-sa/4.0/
 ######################################################################
  ######################################################################
_=$BASH_ARGC
OLDIFS=$IFS 

declare    arr=""
declare -i length=0

## Arg 1 - index 1: First swap index
## Arg 2 - index 2: Second swap index
function swap() { 
 local -a my_array 
 local    tmpval="" 
 local -i index1=${1} 
 local -i index2=${2}  
 OLDIFS=$IFS
 IFS=" " read -ra my_array <<< "${arr}"
 tmpval=${my_array[${index1}]}
 my_array[${index1}]=${my_array[${index2}]}
 my_array[${index2}]=${tmpval}
 IFS=$OLDIFS
 arr="${my_array[@]}"
}

## Arg1 - Integer: size
function heappermutation() { 
 local -i size=${1}
 local -i i=0
 if((${size}==1)); then  
  echo "${arr}"
  return
 fi 
 for((i=0;i<${size};i++)) { 
  heappermutation $((${size}-1)) 
  if(((${size}%2)==1)); then    
   swap 0 $((${size}-1))
  else 
   swap ${i} $((${size}-1))
  fi 
 } 
}

function init() { 
 arr="${BASH_ARGV[@]}"
 length=${BASH_ARGC}
}

function main() { 
 init 
 heappermutation ${length}
} 

if(($#<1))||[[ "${1}" =~ ^- ]]; then 
cat<<EOF 

Usage: ${0##*/} <args=eg. 1 2 3 4 5>
 
 Eg. $> ${0##*/} 1 2 3 
        3 2 1
        2 3 1
        1 3 2
        3 1 2
        2 1 3
        1 2 3
EOF
 exit 1
fi

main
exit 0

Get the latest, replete with an iterative algorithm, on GitHub.

tarf - Pull Selected Files From a Tarball

alias tarf='_(){ (($#<1))||[[ "${1}" =~ ^- ]]&&echo "Usage: tarf <wildcardname eg.*ocean*pdf> <tarfile> <output dir-default=.>"&&return 1;local wildname="${1}";local tar="${2}";local location="${3:-.}";tar -xf "${tar}" -C "${location}" --wildcards "${wildname}" --transform "s,.*/,,";};_'

This alias makes it really easy to grab individual files from a tarball to the current [or specified] directory. Without having to dig through the directory structure or even knowing the exact name of the file. E.g. tarf '*mp4' media.tar.gz ~/mymp4s/;

Get the latest on GitHub.

alx driver - Reenable Wake On Lan

If you use the Linux Atheros driver alx you will very likely find that
Wake on Lan (wol) has been disabled since approximately 2013. When the
author was unable to find fixes for various wake-up issues including the
famous "wakeup twice" problem. This resulted in the author disabling wol
in alx. It turned out that the problem was not in alx at all yet instead
was within buggy firmware on the cards themselves.

Check your current alx driver:
$> sudo ethtool <ethdev,eg.enp3s0>

If you see something along the lines of:
 Supports Wake-on: d
          Wake-on: d

Then your alx has wol disabled.

You can find the history here:
https://bugzilla.kernel.org/show_bug.cgi?id=61651

The patch that disabled wol on alx was eventually reversed and found to
work perfectly. You can install the latest patch (supporting stable
kernel versions 5+) here: https://bugzilla.kernel.org/attachment.cgi?id=284877
(Right-click and choose Save Link As)

After you download it copy it to /usr/src, explode it and run setup:
$> sudo cp alx-dmks-installer-kernel5.tar.gz /usr/src
$> sudo tar xvf alx-dmks-installer-kernel5.tar.gz
$> cd alx-dmks-installer/
$> sudo ./setup

If all went well you should see a message along the lines of
DKMS: install completed.

Now install the newly patched alx driver, installed via dkms:
$> sudo modprobe -r alx && sudo modprobe alx

Note: in my testing, the above works remotely, without dropping your
connection!

Re-check your alx driver for wol support:
$> sudo ethtool <ethdev,eg.enp3s0>

You should now see something along the lines of:
 Supports Wake-on: pg
          Wake-on: g

Make sure to check that you don't have any scripts that unload the alx
driver when going to sleep, I found that I had one on my Ubuntu 19.04
system living in /usr/lib/pm-utils/sleep.d/50unload_alx
Remove any you find.

Now you can test, find your mac address and write it down:
$> ifconfig -a <ethdev,eg.enp3s0> | grep -o 'ether [^ ]*'

On your router turn on port forwarding for UDP Port 9 (Discard Protocol),
to the broadcast address (eg. 192.168.1.255).

Put your computer to sleep:
$> sudo pm-suspend

Now from another computer on the same LAN send a magic packet to the
sleeping computers MAC address on port 9 and voila! It will awaken.