Der Code-Schnippsel-Thread

[DosAmp]

Zum leichten Wiederfinden hier gelagert:

Code:

Windows Registry Editor Version 5.00

; TotallyNotFromTheInternet,Bro.reg

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Attachments​]
"SaveZoneInformation"=dword:00000001

Das Zonenkonzept ist für die Generation DSL ohnehin für die Katz, wenn man seine Software sämtlich nur noch direkt aus dem Internet bezieht oder auf FAT32-formatierten USB-Sticks zwischenparkt und später installiert, auf denen der Zone-Identifier ohnehin nicht abgelegt wird.

[pETe!]

Fragt der dann nicht mehr "Ist potentiell gefährlich, weil aus dem Internet, ihr Computer könnte explodieren?", oder bezieht sich das nur auf den Zonenkram im IE?

[DosAmp]

pETe! schrieb:  Fragt der dann nicht mehr "Ist potentiell gefährlich, weil aus dem Internet, ihr Computer könnte explodieren?", oder bezieht sich das nur auf den Zonenkram im IE?

Die Mainstream-Browser legen damit keine Informationen bei neuen Downloads auf NTFS-Partitionen mehr an, die diese Warnung hervorrufen. Vorhandene Zone-Identifier-ADS bleiben bestehen, können aber mithilfe Tools rekursiv z. B. aus dem Download-Ordner entfernt werden.

[DosAmp]

Dateigröße in C ermitteln
Variante 1: fseek + ftell

Code:

#include <stdio.h>

FILE *f = fopen(path, "rb");
fseek(f, 0, SEEK_END);
long size = ftell(f);
fseek(f, 0, SEEK_SET);
fclose(f);

Variante 2: stat

Code:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

struct stat st;
stat(path, &st);
off_t size = st.st_size;

Variante 3: File Descriptors, fstat()

Code:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int fd = open(path, O_RDONLY);
struct stat st;
fstat(fd, &st);
off_t size = st.st_size;
close(fd);

Hilft natürlich alles nichts, wenn die Daten über stdin hereinkommen und man ein Binärformat parsen will, das in Version 1 aus einer fixen Datenstruktur besteht und optional in Version 2 von denselben Daten mit einer zusätzlichen (String-)Spalte gefolgt wird, an der man auch interessiert ist. Hilft aber abzuschätzen, ob letztere existiert, wenn sie stattdessen aus einer Datei kommen.

[LukeGee]

Falls es jemand gebrauchen kann: (wird weiter ausgebaut)

https://github.com/lukasg/shellfuncs/blo...llfuncs.sh

Code:

################################################################################​
# shellfuncs - some useful bash functions
################################################################################​

PATH=/usr/bin:/usr/sbin:/bin:/sbin

#
# Activates of deactivates verbosity of some functions in here.
#
: ${LIB_VERBOSE:=0}

################################################################################​
# Default return codes as in stdlibc
################################################################################​

EXIT_SUCCESS=0
EXIT_FAILURE=1

################################################################################​
# THE FUNCTIONS
################################################################################​

################################################################################​
# is_true
#    check pseudo-boolean values
#
# Usage:
#    is_true [value]
#
# Arguments:
#    value: pseudo-boolean value to check
#
# Returns:
#    true (rc = 0) if the value equals true
#
is_true()
{
    case "$1" in
        yes|true|YES|TRUE|ja|on|ON|1)
            true
            ;;
        *)
            false
            ;;
    esac
}

################################################################################​
# check_rc
#    checks a programs return code for success for failure
#
# Usage:
#    check_rc [rc]
#
# Arguments:
#    rc: return code of a command
#
# Returns:
#    true (rc = 0) for a successful return code.
#
check_rc()
{
    case "$1" in
        0)
            true
            ;;
        *)
            false
            ;;
    esac
}

################################################################################​
# is_decimal
#    Determines if a value is decimal
#
# Usage:
#    is_decimal [value]
#
# Arguments:
#    value: the value to check
#
# Returns:
#    true (rc = 0) for a decimal value
#
is_decimal()
{
    case "$1" in
        ""|*[!0-9]*)
            false
            ;;
        *)
            true
            ;;
    esac
}

################################################################################​
# is_decimal
#    Determines if a value is hex
#
# Usage:
#    is_hex [value]
#
# Arguments:
#    value: the value to check
#
# Returns:
#    true (rc = 0) for a hex value
#
is_hex()
{
    case "$1" in
        ""|*[!0-9a-fA-F]*)
            false
            ;;
        *)
            true
            ;;
    esac
}

################################################################################​
# is_octal
#    Determines if a value is hex
#
# Usage:
#    is_hex [value]
#
# Arguments:
#    value: the value to check
#
# Returns:
#    true (rc = 0) for a hex value
#
is_octal()
{
    case "$1" in
        ""|*[!0-7]*)
            false
            ;;
        *)
            true
            ;;
    esac
}

################################################################################​
# log
#    Logs a message to stdout or stderr
#
# Usage:
#    log [level] [message]
#
# Arguments:
#    level: the log level may be err, info or debug.
#        err means the message is logged to stder(&2)
#        info means the message is logged to stdout(&1)
#        debug means the message if only logged to stdout(&1)
#        if LIB_VERBOSE is set to a true value.
#    message: the message to log
#
log()
{
    if [ $# -lt 2 ]; then
        log err "log: not enough arguments"
    fi

    local level="$1"
    shift
    local msg="$@"

    case "$level" in
        err)
            echo "$msg" >&2
            ;;
        info)
            echo "$msg"
            ;;
        debug)
            is_true $LIB_VERBOSE && echo "$msg" >&2
            ;;
    esac
}

################################################################################​
# log_syslog
#    Logs a message to syslog
#    As log tag it takes $0 which means the name of the
#    script executing log_syslog.
#
# Usage:
#    log_syslog [message]
#
# Arguments:
#    message: The message which should be logged
#
log_syslog()
{
    local msg="$@"
    local tag="${0#./}"

    logger -t "$tag" "$msg"
}

################################################################################​
# die
#    Logs a message and exits the program with a defined exit code
#
# Usage:
#    die [rc] [message]
#
# Arguments:
#    rc: the exit code to exit the program with
#    message: the message to log to stderr(&2)
#
die()
{
    if [ $# -lt 2 ]; then
        log err "die: not enough arguments"
    fi

    local rc="$1"
    shift
    local msg="$@"

    log err "$msg"

    exit $rc
}

################################################################################​
# exec_or_die
#    Executes a command and exits the program if the command failed
#
# Usage:
#    exec_or_die [command args ...]
#
# Arguments:
#    command args ...: the command with its arguments to execute.
#        Does not have to be quoted.
#
exec_or_die()
{
        local cmd="$@"
        local rc

        log debug "exec_or_die: $cmd"

        ( $cmd )
        rc=$?

        if ! check_rc $rc; then
                die $rc "Command $cmd failed with exit code: $rc"
        else
                return $rc
        fi
}

################################################################################​
# ARRAY HELPER FUNCTIONS
#
# PLEASE NOTE:
#
# These array functions take use of 'eval'. That means that the arguments
# which repesent the array and vars where data shuold be written to
# have to be written WITHOUT the '$'.
#
# EXAMPLE:
#
# myarray=()
# array_push myarray "first element"
# foovar=
# array_get_first myarray foovar
# echo $foovar
#
################################################################################​

################################################################################​
# array_push
#    Pushes a value to an array
#
# Usage:
#    array_push [array] [value]
#
# Arguments:
#    array: the array where the values should be pushed to
#    value: the value that should be pushed
#
array_push()
{
    local array="$1"
    shift

    for value in "$@"; do
        eval "$array[\${#$array[@]}]=\$value"
    done
}

################################################################################​
# array_get
#    Gets an value from an array an sets it to a var
#
# Usage:
#    array_get [array] [destination] [index]
#
# Arguments:
#    array: the array
#    destination: the destination var
#    indext: the index of the var in the array
#
array_get()
{
    local src="$1"
    local dst="$2"
    local idx="$3"

    eval "$dst=\${$src[$idx]}"
}

################################################################################​
# array_get_first
#    Gets the first element of an array
#
# Usage:
#    array_get_first [array] [destination]
#
# Arguments:
#    array: the array where to get the value from
#    value: the value that should be pushed
#
array_get_first()
{
    local src="$1"
    local dst="$2"

    array_get $src $dst 0
}

################################################################################​
# array_get_last
#    Gets the last element of an array
#
# Usage:
#    array_get_last [array] [destination]
#
# Arguments:
#    array: the array where to get the value from
#    value: the value that should be pushed
#
array_get_last()
{
    local src="$1"
    local dst="$2"

    array_get $src $dst -1
}

################################################################################​
# array_copy
#    Copies an array to another
#
# Usage:
#    array_copy [array] [destination]
#
# Arguments:
#    array: the source array
#    destination: the destination array
#
array_copy()
{
    local src="$1"
    local dst="$2"

    eval "$dst=(\"\${$src[@]}\")"
}

################################################################################​
# array_set
#    Sets the value of an array
#
# Usage:
#    array_set [array] [index] [value]
#
# Arguments:
#    array: the array
#    index: the index of the element
#    value: the value that should be set

array_set()
{
    local array="$1"
    local idx="$2"
    local value="$3"

    eval "$array[$idx]=\$value"
}

################################################################################​
# array_reset
#    Resets an array to zero or to the defined elements
#
# Usage:
#    array_reset [array] {[values] ...}
#
# Arguments:
#    array: the array that sould be resetted
#    values...: optional values with which the array should be re-initialized
#
array_reset()
{
    local array="$1"
    shift

    eval "$array=(\"\$@\")"
}

[gandro]

Sehr coole Idee, schön umgesetzt, gefällt mir.

[DosAmp]

Verbesserte Version meines Icon-Cache-Scripts, jetzt in PowerShell und allgemeingültig für alle Shells und unterstützten NTs:

Code:

[Environment]::GetFolderPath('LocalApplicationData') | pushd
rm -ErrorAction:SilentlyContinue -Force IconCache.db
popd
$shell = (gp 'HKCU:\Software\Microsoft\Windows NT\CurrentVersion\Winlogon').Shell
if ($shell -eq $NULL) {
    $shell = (gp 'HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Winlogon').Shell
}
# unix equivalent: shellproc=`basename $shell`
$shellproc = (Split-Path -Leaf $shell)
if ($shellproc.ToLower().EndsWith('.exe')) {
    $shellproc = $shellproc.Substring(0, $shellproc.Length - 4)
}
kill -Name $shellproc
sleep 2
# if shell not restarted by session manager
if ((ps -ErrorAction:SilentlyContinue $shell) -ne $NULL) {
    start $shell
}

[oreissig]

ein uberhackiges JScript, welches über SendKeys das NVRAM einer per Terminal angeschlossenen Sun "fixt" (MAC 8:0:20:c0:ff:ee, HostID c0ffee)

da openprom offenbar keine flusskontrolle am seriellen port macht, kann man sich die sequenz nicht einfach reinguttenbergen oder in einem rutsch sendkeys machen, sondern muss immer kleine päuschen einbauen

Code:

var delay = 20;

var WshShell = WScript.CreateObject("WScript.Shell");

WScript.Echo("Press OK to bring PuTTY into foreground and fix NVRAM");
WshShell.AppActivate("COM1 - PuTTY");
WScript.Sleep(100);

sendKeys("17 0 mkp");
sendKeys("8 0 20 c0 ff ee c0ffee mkpl");
WshShell.SendKeys("^D");
WScript.Sleep(2*delay);
WshShell.SendKeys("^R");

sendKeys("set-defaults");
WScript.Sleep(2500);

sendKeys("setenv diag-switch? false");
sendKeys("setenv auto-boot? false");

sendKeys("reset");

WScript.Echo("finished :-)");


function sendKeys(keys)
{
    for (var i=0; i<keys.length; i++) {
        WScript.Sleep(delay);
        WshShell.SendKeys(keys.charAt(i));
    }
    WshShell.SendKeys("{ENTER}");
}

[thosch97]

Warum nicht expect? So ala expect ok LFsend 17 0 mkp und so
Ja ich weiss, die Syntax wird nicht stimmen und code oder tt ist es auch nicht... hab aber grad Ami/Lazout auf DE-Tastatur und find die Haelfte nich

[oreissig]

(09.04.2012 20:36)thosch97 schrieb:  Warum nicht expect? So ala expect ok LFsend 17 0 mkp und so

schon innerhalb einer zeile klappt das nicht, man muss wirklich zwischen jedem zeichen (oder vll alle 2 oder so, aber nicht nur bei neuem Prompt) ne Pause machen
außerdem wüsst ich nicht, wie ich PuTTY direkt skripten kann. so brauch ich halt keine modifikationen am terminalprog

darfst es natürlich gern anpassen. bisher ists eben auch windows-spezifisch, weil ich nicht wusste, ob es sowas wie SendKeys auch halbwegs standardmäßig unter linux o.ä. gibt