Der Code-Schnippsel-Thread

@echo off
set INTERFACE="LAN-Verbindung"


rem d„mliche Umlaute
netsh interface ipv4 show config name=%INTERFACE% | find "Subnetzpr" > %temp%\uphosts.tmp
rem Unix-Äquivalent: SUBNET=`awk '{print $2}'`
for /f "tokens=2" %%t in (%temp%\uphosts.tmp) do set SUBNET=%%t


netsh interface ipv4 show config name=%INTERFACE% | find "IP-Adresse" > %temp%\uphosts.tmp
for /f "tokens=2" %%s in (%temp%\uphosts.tmp) do set OWNIP=%%s


del %temp%\uphosts.tmp


nmap -sn -n --exclude %OWNIP% %SUBNET%

import urllib2
import sys
import base64
import re
import sgmllib
import pdfminer
from pdfminer.pdfparser import PDFDocument, PDFParser
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter, process_pdf
from pdfminer.pdfdevice import PDFDevice
from pdfminer.converter import XMLConverter


urls = ("https://www1.ethz.ch/inf/intranet/evaluation/fs11", "https://www1.ethz.ch/inf/intranet/evaluation/hs11/index")
username = "nethzusername"
password = "nethzpasswort"
tmpfile = "tmp.pdf"
mwOfInterest = 10


class MyParser(sgmllib.SGMLParser):
  def parse(self, s):
    self.feed(s)
    self.close()


  def __init__(self, verbose=0):
    sgmllib.SGMLParser.__init__(self, verbose)
    self.pdfs = []
    self.titles = []
    self.pdffinder = re.compile(r'''.*\.pdf''', re.IGNORECASE)
    self.titlefinder = re.compile(r'''.*\'(.*)\'.*''', re.IGNORECASE)
  def start_a(self, attributes):
    active = False
    for name, value in attributes:
      if name == "href":
        if (self.pdffinder.match(value)):
          active = True
          self.pdfs.append(value)
      if name == "title":
        if (active):
          self.titles.append(self.titlefinder.match(value).group(1))


  def get_pdfs(self):
    return self.pdfs
  def get_titles(self):
    return self.titles


class MyOutWriter():
  def __init__(self):
    self.lines = []
  def write(self, string):
    self.lines.append(string)
  def get_lines(self):
    return self.lines


def geturl(theurl, username, password):
  print "Getting url '%s'..." % theurl
  req = urllib2.Request(theurl)
  try:
    handle = urllib2.urlopen(req)
  except IOError, e:
    print "URL requires authorization. Authenticating..."
    authline = e.headers['www-authenticate']
    authobj = re.compile(
      r'''(?:\s*www-authenticate\s*:)?\s*(\w*)\s+realm=['"]([^'"]+)['"]''',
      re.IGNORECASE)
    matchobj = authobj.match(authline)
    base64string = base64.encodestring('%s:%s' % (username, password))[:-1]
    authheader = "Basic %s" % base64string
    req.add_header("Authorization", authheader)
    try:
      handle = urllib2.urlopen(req)
    except IOError, e:
      print "Could not authenticate."
      return ""
  print "Authenticated."
  thepage = handle.read()
  return thepage
  
def parsepdf(fp):
  parser = PDFParser(fp)
  doc = PDFDocument()
  parser.set_document(doc)
  doc.set_parser(parser)
  pdfpass = ''
  doc.initialize(pdfpass)
  if not doc.is_extractable:
    raise PDFTextExtractionNotAllowed
  rsrcmgr = PDFResourceManager()
  outfp = MyOutWriter()
  device = XMLConverter(rsrcmgr, outfp)
  process_pdf(rsrcmgr, device, fp)
  return outfp.get_lines()


def extractMWs(pdflines):
  mws = []
  for i, line in enumerate(pdflines):
    if line == 'M':
      if(pdflines[i+3] == 'W' and 
        pdflines[i+6] == ' ' and
        pdflines[i+9] == '='):
        try:
          mws.append(float(pdflines[i+12])+0.1*float(pdflines[i+18]))
        except ValueError, e:
          print "Could not convert to float: %s%s" % (pdflines[i+12], pdflines[i+18])
          mws.append(0.0)
  return mws


zipbag = []
for url in urls:
  mainpage = geturl(url, username, password)
  myparser = MyParser()
  myparser.parse(mainpage)
  pdfs = myparser.get_pdfs()
  titles = myparser.get_titles()


  for i, pdf in enumerate(pdfs):
    pdfsource = geturl(pdf, username, password)
    fp = open(tmpfile, 'w')
    fp.write(pdfsource)
    fp.close()
    fp = open(tmpfile, 'rb')
    mws = extractMWs(parsepdf(fp))
    try:
      mw = mws[mwOfInterest]
    except IndexError, e:
      print "Could not get MW... taking 0.0 instead"
      mw = 0.0
    zipbag.append((titles[i], mw))


for tpl in sorted(zipbag, key=lambda x: x[1]):
  print "%s: %f" % tpl

CONST mwst% = 19
'für die Anschrift
DIM name$, strasse$, plz$, ort$
'fr die Artikel
DIM artikel1$, artikel2$, artikel3$
DIM anzahl1%, anzahl2%, anzahl3%
DIM preis1!, preis2!, preis3!
'Rechenfelder
DIM gesamt1!, gesamt2!, gesamt3!
DIM sumpreis!, sumgesamt!, mehrwert!


'Adresse eingeben
CLS
PRINT "Bitte geben Sie die Anschrift des Kunden ein"
PRINT
PRINT
INPUT "Name:    ", name$
INPUT "Strasse: ", strasse$
INPUT "PLZ:     ", plz$
INPUT "Ort:     ", ort$


'Artikel eingeben
CLS
PRINT "Bestellung eingeben für " + name$
PRINT
PRINT "Artikel 1"
INPUT "Artikel: ", artikel1$
INPUT "Anzahl:  ", anzahl1%
INPUT "Preis:   ", preis1!
gesamt1! = anzahl1% * preis1!
PRINT
PRINT "Artikel 2"
INPUT "Artikel: ", artikel2$
INPUT "Anzahl:  ", anzahl2%
INPUT "Preis:   ", preis2!
gesamt2! = anzahl2% * preis2!
PRINT
PRINT "Artikel 3"
INPUT "Artikel: ", artikel3$
INPUT "Anzahl:  ", anzahl3%
INPUT "Preis:   ", preis3!
gesamt3! = anzahl3% * preis3!


'Ausgabebildschirm erzeugen
CLS
LOCATE 2, 5
PRINT "Rechnungsblatt"
LOCATE 4, 5
PRINT name$
LOCATE 5, 5
PRINT strasse$
LOCATE 6, 5
PRINT plz$ + " " + ort$
LOCATE 8, 5
PRINT "Artikel"; TAB(45); "Anz"; TAB(50);
PRINT "Preis"; TAB(65); "Gesamt"
LOCATE 9, 5
PRINT artikel1$
LOCATE 9, 45
PRINT USING "###"; anzahl1%
LOCATE 9, 50
PRINT USING "######,.##"; preis1!; TAB(65);
PRINT USING "######,.##"; gesamt1!
LOCATE 10, 5
PRINT artikel2$
LOCATE 10, 45
PRINT USING "###"; anzahl2%
LOCATE 10, 50
PRINT USING "######,.##"; preis2!; TAB(65);
PRINT USING "######,.##"; gesamt2!
LOCATE 11, 5
PRINT artikel3$
LOCATE 11, 45
PRINT USING "###"; anzahl3%
LOCATE 11, 50
PRINT USING "######,.##"; preis3!; TAB(65);
PRINT USING "######,.##"; gesamt3!
sumpreis = preis1! + preis2! + preis3!
sumgesamt = gesamt1! + gesamt2! + gesamt3!
mehrwert! = sumgesamt! * mwst% / 100
LOCATE 15, 30
PRINT "Summe: "; TAB(50);
PRINT USING "######,.##"; sumpreis!; TAB(65);
PRINT USING "######,.##"; sumgesamt!
LOCATE 16, 30
PRINT USING "MWST ###%"; mwst%; TAB(65);
PRINT USING "######,.##"; mehrwert!
LOCATE 17, 30
PRINT "Rechnungsbetrag: "; TAB(65);
PRINT USING "######,.##"; sumgesamt! + mehrwert!

################################################################################
# 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=(\"\$@\")"
}