Mittwoch, 13. Juli 2022

Lösung: ping: socket: Operation not permitted. Kein ping als normaler Benutzer. Debian 10 buster.

Nach einem Update funktioniert ping nicht mehr als normaler Benutzer.

Anscheinend gab es eine Sicherheitslücke, welche gefixt werden musste.

 

Habe einen Standard Debian Kernel:

SMP Debian 4.19.249-2 (2022-06-30)

 

In diesem SUSE Supportartikel wird das Symptom beschrieben:

There are two components to be considered, file capabilities (cap_net_raw+eip)  and net.ipv4.ping_group_range kernel parameter.

 

Bei mir gab es keine Ausgabe für den Befehl

 root@pb:~# getcap /bin/ping

Die Ausgabe für

root@pb:~# sysctl net.ipv4.ping_group_range
net.ipv4.ping_group_range = 1    0

brachte den Grund hervor.

Man kann jetzt entweder den Bereich der Gruppennummern auf 1 bis 2147483647 setzen

oder 

mit setcap arbeiten.

Lösung 1:

root@pb:~# sysctl net.ipv4.ping_group_range="1 2147483647"
 

Lösung 2: 

root@pb:~# setcap cap_net_raw+eip /bin/ping
root@pb:~# getcap /bin/ping
/bin/ping = cap_net_raw+eip
 

Der Grund für die Änderung der ping Berechtigungen seitens Debian kommt wschl. wegen dieser CVE (Common Vulnerabilities and Exposures) 

CVE-2015-3636


Fazit:

Lösung 2 bevorzugen.


TODO:

Permanent machen von Lösung 2



Freitag, 2. April 2021

Softlinks in Linux auflösen mit readlink

Ein Softlink in Linux wird mit 

ln -s linkziel linkname

erzeugt.

Dabei darf ein Link auf einen Ordner, eine Datei oder einen anderen Link verweisen.

Durch Letzteres gibt es die Situation, dass man von einem Dateipfad nicht sicher sein kann, dass alle Pfadbestandteile wirklich existieren.

Nehmen wir einen lokalen Pfad a/b/c/datei.txt an.

Dann kann jedes Element darin ein Softlink sein.

Um den echten Pfad aufzulösen gibt es den Linux Befehl readlink.

Ohne Optionen gibt es nur das Endziel des Softlinks nach Auflösung jedes Bestandteils des Pfades aus.

 Mit Option -e müssen alle Bestandteile des Pfades aufgelöst werden können.

Es wird dann der um Softlinks bereinigte vollständige Dateipfad ausgegeben.

Mit Option -f darf der letzte Bestandteil des aufgelösten Dateipfades nicht vorhanden sein; d.h.

Aus a/b/c/datei.txt wird z.B. /d/e/f/g/h/zieldatei.txt.
Dann muss der Pfad /d/e/f/g/h/ existieren und zieldatei.txt darf fehlen im Dateisystem.

 

Mit Option -m werden alle Pfadbestandteile soweit wie möglich aufgelöst und wenn dies nicht möglich so belassen und mit dem Restpfad konkateniert.

 

Fazit:

Nur die Variante mit Option -e macht Sinn.

 

Nachfolgend ein Beispiellauf mit letztem Softlink "mehrpfadig":

 noname@pb:~/todel/linktest$ ls -l
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 15:44 a
lrwxrwxrwx 1 noname noname    6 Apr  2 15:17 start -> a/lElb
noname@pb:~/todel/linktest$ ls -l a
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 15:58 b
lrwxrwxrwx 1 noname noname    1 Apr  2 15:44 lEb -> b
lrwxrwxrwx 1 noname noname    3 Apr  2 15:10 lElb -> lEb
lrwxrwxrwx 1 noname noname    2 Apr  2 15:08 lNb2 -> b2
noname@pb:~/todel/linktest$ ls -l a/b
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 13:05 c
-rw-r--r-- 1 noname noname    0 Apr  2 15:24 fba
lrwxrwxrwx 1 noname noname    3 Apr  2 15:09 lEb -> lEb
lrwxrwxrwx 1 noname noname   18 Apr  2 15:58 lNexisting -> blabla/tests/gsddg
noname@pb:~/todel/linktest$ readlink start/lNexisting
blabla/tests/gsddg
noname@pb:~/todel/linktest$ readlink -e start/lNexisting
noname@pb:~/todel/linktest$ readlink -f start/lNexisting
noname@pb:~/todel/linktest$ readlink -m start/lNexisting
/home/noname/todel/linktest/a/b/blabla/tests/gsddg

   

 Beispiellauf mit letztem Link "einpfadig":

noname@pb:~/todel/linktest$ ln -snf blabla a/b/lNexisting
noname@pb:~/todel/linktest$ ls -l
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 15:44 a
lrwxrwxrwx 1 noname noname    6 Apr  2 15:17 start -> a/lElb
noname@pb:~/todel/linktest$ ls -l a 
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 16:17 b
lrwxrwxrwx 1 noname noname    1 Apr  2 15:44 lEb -> b
lrwxrwxrwx 1 noname noname    3 Apr  2 15:10 lElb -> lEb
lrwxrwxrwx 1 noname noname    2 Apr  2 15:08 lNb2 -> b2
noname@pb:~/todel/linktest$ ls -l a/b
total 4
drwxr-xr-x 3 noname noname 4096 Apr  2 13:05 c
-rw-r--r-- 1 noname noname    0 Apr  2 15:24 fba
lrwxrwxrwx 1 noname noname    3 Apr  2 15:09 lEb -> lEb
lrwxrwxrwx 1 noname noname    6 Apr  2 16:17 lNexisting -> blabla
noname@pb:~/todel/linktest$ readlink start/lNexisting
blabla
noname@pb:~/todel/linktest$ readlink -e start/lNexisting
noname@pb:~/todel/linktest$ readlink -f start/lNexisting
/home/noname/todel/linktest/a/b/blabla
noname@pb:~/todel/linktest$ readlink -m start/lNexisting
/home/noname/todel/linktest/a/b/blabla

 

Linux ls Kommando - Was bedeutet total ?

Wenn ein Verzeichnis mit dem Kommando ls -l aufgelistet wird, gibt es ja immer einen Vorspann der Art

noname@pb:~/todel/linktest$ ls -l a/b/c/d/e
total 24
drwxr-xr-x 2 noname noname       4096 Apr  2 13:29 f
drwxr-xr-x 2 noname noname       4096 Apr  2 13:25 f2
drwxr-xr-x 2 noname noname       4096 Apr  2 13:26 f3
drwxr-xr-x 2 noname noname       4096 Apr  2 13:28 f4
drwxr-xr-x 4 noname noname       4096 Apr  2 13:31 f5
-rw-r--r-- 1 noname noname 4194305024 Apr  2 13:52 fa
-rw-r--r-- 1 noname noname          0 Apr  2 13:28 fa2

Was bedeuet die Zahl 24?

Wie man bei GNU coreutils nachlesen kann, ist das die Summe aller direkten Einträge im aktuellen Ordner, dargestellt in der Standard Blockgröße 1024 Bytes ; Standard Blockgröße für die Kommandoausgabe (!=Dateisystemblockgröße).

Es wird hierbei der reale Platzverbrauch der Daten- und Verzeichnisdateien im Ordner berücksichtigt.

Verzeichnisdateien haben unabhängig von ihrem eigenen Inhalt nach ihrer Erzeugung eine konstante und fixe Größe von hier 4096 Bytes.

Die Datendateien können aber sogenannte Sparse Dateien sein, welche nominal größer sein können als ihr realer Plattenverbrauch im Dateisystem.

Man kann eine solche Sparse Datei z.B. mit dd erzeugen, was hier gemacht wurde:

noname@pb:~/todel/linktest$ dd if=/dev/zero of=a/b/c/d/e/fa bs=1k seek=4000k count=1
1+0 Datensätze ein
1+0 Datensätze aus
1024 bytes (1,0 kB, 1,0 KiB) copied, 0,000499488 s, 2,1 MB/s

Die reale Größe läßt sich hiermit anzeigen:

noname@pb:~/todel/linktest$ du -B 1 a/b/c/d/e/fa
4096    a/b/c/d/e/fa

Jetzt schauen wir uns nochmal die Auflistung des Ordners in Bytes an:

noname@pb:~/todel/linktest$ ls -l --block-size="1" a/b/c/d/e
total 24576
drwxr-xr-x 2 noname noname       4096 Apr  2 13:29 f
drwxr-xr-x 2 noname noname       4096 Apr  2 13:25 f2
drwxr-xr-x 2 noname noname       4096 Apr  2 13:26 f3
drwxr-xr-x 2 noname noname       4096 Apr  2 13:28 f4
drwxr-xr-x 4 noname noname       4096 Apr  2 13:31 f5
-rw-r--r-- 1 noname noname 4194305024 Apr  2 13:52 fa
-rw-r--r-- 1 noname noname          0 Apr  2 13:28 fa2

Der Ordner  a/b/c/d/e hat also in Summe seiner direkten Kinder:

realsize(f)+realsize(f2)+realsize(f3)+realsize(f4)+realsize(f5)+realsize(fa)+realsize(fa2)

 folgendes Ergebnis: 4096+4096+4096+4096+4096+4096+0 = 24576

noname@pb:~/todel/linktest$ echo $((4096*6))
24576

Ein nachträgliches befüllen von existierenden Unterordnern ändert nichts an dieser Summe!

Hier am Beispiel des Unterordners f vom betrachteten Ordner e.

Wie man hier sieht, ist der Ordner zu Anfang leer gewesen:

noname@pb:~/todel/linktest$ ls -l --block-size="1" a/b/c/d/e/f
total 0

Jetzt erzeugen wir eine Sparse Datei darin:

noname@pb:~/todel/linktest$ dd if=/dev/zero of=a/b/c/d/e/f/fa3 bs=1k seek=4000k count=1
1+0 Datensätze ein
1+0 Datensätze aus
1024 bytes (1,0 kB, 1,0 KiB) copied, 0,000475806 s, 2,2 MB/s
noname@pb:~/todel/linktest$ du -B 1 --apparent-size a/b/c/d/e/f/fa3
4194305024    a/b/c/d/e/f/fa3
noname@pb:~/todel/linktest$ du -B 1 a/b/c/d/e/f/fa3
4096    a/b/c/d/e/f/fa3
noname@pb:~/todel/linktest$ ls -l --block-size="1" a/b/c/d/e/f
total 4096
-rw-r--r-- 1 noname noname 4194305024 Apr  2 13:57 fa3
 

Die Ursprüngliche Ausgabe von ls für der Ordner e bleibt von dieser Änderung unberührt:

noname@pb:~/todel/linktest$ ls -l --block-size="1" a/b/c/d/e
total 24576
drwxr-xr-x 2 noname noname       4096 Apr  2 13:29 f
drwxr-xr-x 2 noname noname       4096 Apr  2 13:25 f2
drwxr-xr-x 2 noname noname       4096 Apr  2 13:26 f3
drwxr-xr-x 2 noname noname       4096 Apr  2 13:28 f4
drwxr-xr-x 4 noname noname       4096 Apr  2 13:31 f5
-rw-r--r-- 1 noname noname 4194305024 Apr  2 13:52 fa
-rw-r--r-- 1 noname noname          0 Apr  2 13:28 fa2

 

Dienstag, 1. Oktober 2019

Informationen zu Gateways und Routing unter Windows

Informationen zu Gateways:

0) Auf Windows 7 muss der Dienst Routing und RAS laufen, damit zwischen den einzelnen NIC Subnetzen Daten geroutet werden. Das Anhalten des Dienstes ist im Verhalten gleich dem Gestartetsein. Also wenn man kein Routing haben will, dann muss man den Dienst wirklich beenden. Ohne Routing und RAS kann man aber als Host, welcher ja mehrere NICs besitzen kann um damit Mitglied der verschiedenen Subnetze sein zu können, kann man aber die Subnetz Mitglieder erreichen. Nur die Kommunikation von anderen Subnetz Mitgliedern untereinander wird durch das Abschalten des R.u.-RAS unmöglich.

1) Jedes Gateway auf einer Netzwerkschnittstelle kann nur die IP der Schnittstelle oder eine IP auf dem zugehörigen Subnetz sein.

2) Das Gateway für das Netzwerk einer Netzwerkschnittstelle ist immer die IP der Schnittstelle, d.h. der Rechner selbst ist sein Gateway

3) Ist kein Default Gateway definiert, so ist die IP der Netzwerkschnittstelle selbst per Definition das Default Gateway

4) In der Routingtabelle wird das Zielnetzwerk für ein Paket bestimmt. Im ersten Schritt wird das Gateway bestimmt, welches entweder

4.1) die IP der Netzwerkschnittstelle ist:
Es wird in der Routingtabelle des Rechners, welcher mehr als eine Netzwerkschnittstelle besitzen kann, ermittelt für welchen Empfänger das Paket ist.
4.1.1) Falls es einer der IPs seiner NICs ist, dann erfolgt die Auslieferung an diesen Rechner selbst.

4.1.2) Falls nicht, dann wird über alle Routen auf allen NICs ermittelt, ob es einen Ausgang gibt. Unter den vielen möglichen Ausgängen wird jenes gewählt, das die kleinsten Kosten ausgedrückt als Metrik besitzt. Auf diesem Ausgang wird an das ermittelte Gateway an dessen mit arp aufgelöste MAC Adresse das IP Paket mit der unveränderten IP Quell- und Zieladresse gesendet. Das Gateway erhält also auf seinem MAC Level ein IP Packet, das nicht seine IP als Zieladresse aufweist. Wenn das Gateway nicht als Router konfiguriert ist, wird es ein solches Paket verwerfen. 

4.2) eine IP im Netzwerk der Netzwerkschnittstelle:
Es wird die MAC Adresse des Gateways per arp ermittelt. Dann wird das IP Paket mit unveränderter IP Zieladresse an die Ethernetadresse des Gateways geschickt.
Der Gateway Rechner bekommt also ein Ethernet Paket, das zwar seine MAC Zieladresse trägt, aber dessen IP Nutzlast eine Ziel-IP hat, die nicht seine Eigene ist. Für die weitere Behandlung ist der Gateway verantwortlich.

5) Man kann auf Senderseite nicht bestimmen, dass ein Paket über einen bestimmten Zwischenknoten gehen soll.

3) Will man 5) erreichen, so geht das nur mit:
3.1) Man benutzt auf Senderseite einen Proxy, dessen Proxyadresse der Zwischenknoten ist. Dann muss auf dem Zwischenknoten auch ein Proxy Server laufen. Dabei werden die eigentlichen Zieladressen dem Proxy als Content im IP Paket mitgeteilt. Das Proxy Protokoll ist ein Anwendungsprotokoll, das mit IP an den Proxy Server und Client gesendet wird und welches dann auf den Endpoints entpackt und ausgewertet wird. Also encapsultated FTP(udp), HTTP(TCP),SMTP(UDP?).

3.2) Das verwendete Gateway weiss um den Willen des Senders und richtet mittels iptables eine Forwarding rule ein, mit dem es die Pakete vom Sender an den geünschten Zwischenknoten sendet und diesem es überläßt das Paket zu routen. Der Zwischenknoten muss hierbei aber auch so konfiguriert sein, dass er eine funktionierende Rückroute an den ersten Sender hat.

3.3) Das verwendete Gateway weiss um den Willen des Senders und macht ein transparentes Routing aka transparentes Proxying. Dabei verwendet es NAT im MASQUERADING Modus. Es erzeugt also dynamisch Proxy Verbindungen mit seiner IP im Netz des Zwischenknotens und leitet den Verkehr darüber stellvertretend für den Ausgangsserver weiter. Dabei merkt er sich die ausgehende Verbindung und rückübersetzt die Antworten an den Ausgangsserver zurück. Dies nennt man transparentes Proxying, da der Client nicht konfiguriert werden muss. DNAT ist also gleichbedeutend mit transparentem Proxing.

3.3) Das verwendete Gateway weiss um den Willen des Senders und hat eine Netzwerkbrücke über die Netzwekschnittstellen "Mit_Sender_Verbunden"  "Mit_Zwischenknoten_Verbunden" eingerichtet. Auf diesem Brücken-NIC kann er nun sowohl eine IP aus dem "Mit_Sender_Verbunden" Netzwerk als auch Eine aus dem "Mit_Zwischenknoten_Verbunden" Netzwerk vergeben. Dadurch dass das Gateway nun über sein Brücken-NIC direkten Zugang zum Zwischenknoten hat (Ethernet-Ebene), kann es als sein Brücken-NIC als default Gateway die IP des gewünschten Zwischenknotens eintragen und es wird klappen. Denn der Zwischenknoten ist nun in einem seiner Subnetze, die per Brücken-NIC vereint sind.
Notiz: VMWare-Host-Only-Nic läßt sich leider nicht in eine Brücken-NIC eintragen. Der Adapter unterstützt diese Operation nicht. Aber theoretisch ist die Zusammenschaltung von Subnetzen in Brückennetzen möglich unter Windows.

3.3.1) Variante: Brücke auf Ebene 2 (Link-Layer?, MAC Ebene)
Die beiden NICs des Host, die Zugang zur Brücken-NIC haben, bekommen eine zweite IP aus dem Fremd-Subnetz bzw. können sich eine vergeben. Dann können sie arp verwenden, um die IPs aus beiden Subnetzen zu ermitteln. Der Brücken-NIC braucht keine IP, da es sich wie ein HUB bzw. Layer-2-Switch verhält und die Ausgangs Nicks an diesen angeschlossen sind.

3.3.2) Variante: Brücke auf Ebene 3 (IP Layer)
Die Brücken-NIC ist als Router zu betrachten, der zwei NICs hat, welche jeweils mit den Subnetzen der beteiligten Ausgangssubnetze verbunden sind. Hier muss der Brücken-Nic je eine freie IP aus den beiden Ausgangssubnetzen bekommen und die Ausgangsnics müssen eine Route zum jeweiligen anderen Subnetz über die Gatewayadresse des Brücken-Nics setzen. Die jeweilige Brücken NIC ist ja jeweils aus einem Netz ein erreichbares Ziel.

3.3.3) Am ehesten ist Variante 3.3.1 zu vermuten!!!

==========================================================

IP Protokoll:

Ist Vermittlungsprotokoll und entspricht OSI ...

Sein Content sind Transportprotokolle.
Diese Umfassen ICMP (echo,Flussteuerung - SourceQuench,...), TCP (6), UDP(7?9?),

Kennen nur Quell und Ziel IPs.

Routing passiert auf IP Ebene.

Daneben gibt es Transportschichtebene nur für TCP und UDP Portnummern.
Diese klassifizieren einige wohl bekannte Anwendungsprotokolle auf Anwendungsebene, je TCP oder UDP verschiedene. Es ist also möglich, dass ein und dieselbe Portnummer für verschiedene Anwendungen steht, je nachdem, ob es sich um TCP oder UDP als darunterliegendes Transportprotokoll handelt.

Einige Anwendungsbeispiele:
UDP: SMTP(25), ftp(23), DNS, etc.
TCP: HTTP(80), HTTPS(443), etc.

Sowohl bei UDP als auch bei TCP kennt man Sockets und Socket-Pairs.
Dabei ist ein Socket das Tupel Socket=(IPAdress,Portnumber).
Ein Socket-Pair ist ein Tupel SocketPair=(SourceSocket,TargetSocket).

Derjenige, welcher zuerst eine Verbindung zum Anderen aufbaut, ist in der Rolle des Client und der Andere in der des Servers.

Der Server wird mit der Well-Known Portangabe im TargetSocket angesprochen.
Der Port im SourceSocket wird dynamisch zugewiesen und nachdem der Target angesprochen ist, kennt dieser den SourceSocket und damit dessen dynamischen Port. Wenn der TargetSocket nun dem Sender antworten möchte, dann verwendet er einfach den SourceSocket als seinen TargetSocket und den TargetSocket des Senders als seinen SourceSocket.

Im Gegensatz zu TCP kennt das UDP Protokoll keine verbindungsorientierte Kommunikation, in der die Reihenfolge der Empfang gesendeten Inhalte in der Socketkommunikation auf Transportprotokollebene sichergestellt ist. Vielmehr kann dies auf Anwendungsebene z.B. ftp geschehen. Die Verantwortung obliegt also der Anwendung.

Bei TCP hingegen wird der Anwendungsebene als Transportprotokollfeature diese Funktionalität bereitgestellt, so dass die Anwendung sichergehen kann, dass Daten als geordneter Strom von Bytes vorliegen. Dazu baut das TCP eine virtuelle Verbindung über ein 3-Wege-Handshake auf und schließt am Ende der Kommunikation diese über ein weiteres 2?-Handshake. Dazu werden sogenannte SYN,ACK,FIN, etc Flags im TCP Header verwendet und außerdem SIDs (Startzähler beim Client und Server) zur Bestätigung der zuletzte empfangenen Bytenummern als Bestätigungsmarker (ACK) mitgeschickt. Es wird außerdem ein Empfangsfenster definiert, bis zu der einer der Kommunikationspartner Bytes senden darf, bevor noch eine Bestätigung des Empfangs eintritt. Quasi ein Blankobrief, bis zu der alles gesendet werden darf. Der Empfänger kann nun z.B. nur die Hälfte des Empfangs bestätigen und der Sender beginnt das erneute Senden ab der neuen Position ohne weiteres zutun des Anwendungsprogrammes. Das Neusenden erfolgt dabei nach einem Timeout, wenn bis dahin die gesendeten Bytepositionen nicht bestätigt werden.
??Entweder auf ICMP Ebene, Geschwisterprotokoll zu TCP, oder zusätzlich auf TCP Ebene kann der Empfänger den Sender dazu auffordern, das Sendevolumen zu drosseln. Im letzteren Fall in Verbindung mit TCP über das setzen eines kleineren Sendefensters. Wschl. ist die Benutzung von ICMP SourceQuench allgemein das Signal, dass die IP Schicht allgemein die Verarbeitung beliebiger Transportprotokolle nicht bewältigen kann und daher IP Paket im Empfangspuffer verloren zu gehen drohen.

?Ein Socket-Pair ist immer als ein Vollduplex Kanal zu betrachten. Wenn der Client sendet, dann schreibt es in seinen lokalen Socket. Aufgrund dessen, dass dieser mit dem Remote-Socket verbunden ist, landet alles beim Remote-Server.
Wenn der Client empfängt, dann liest es seinen lokalen Socket. Wiederum ließt er mittelbar aus dem Remote-Socket.
Der Sever seinerseits sendet an den Client, indem er in seinen lokalen Socket, welcher der Remote-Socket des Clients war, schreibt und es landet im Remote-Socket des Servers (=lokaler Socket des Clients). Analog ließt er seinen lokalen Socket und mittelbar damit seinen Remote-Socket.

Die jeweiligen Remote Sockets im Gespann von SocketPair=(LocalSocket,RemoteSocket) werden also nur mittelbar über den LocalSocket gelesen oder geschrieben.
 

Beispiel wie diff funktioniert

Beispiel wie diff -d funktioniert:

root@debianxc:~# cat gcc4.txt
float.h
iso646.h
limits.h
mf-runtime.h
ssp.h
stdio.h
string.h
unistd.h
stdarg.h
stdbool.h
stddef.h
stdfix.h
stdint-gcc.h
stdint.h
syslimits.h
unwind.h
varargs.h
root@debianxc:~# cat gcc6.txt
backtrace-supported.h
backtrace.h
float.h
iso646.h
omp.h
openacc.h
stdalign.h
stdarg.h
stdatomic.h
stdbool.h
stddef.h
stdfix.h
stdint-gcc.h
stdint.h
stdnoreturn.h
unwind.h
varargs.h
root@debianxc:~# diff -d gcc4.txt gcc6.txt #Zeige minimalstes ed Skript
0a1,2
> backtrace-supported.h
> backtrace.h
3,8c5,7
< limits.h
< mf-runtime.h
< ssp.h
< stdio.h
< string.h
< unistd.h
---
> omp.h
> openacc.h
> stdalign.h
9a9
> stdatomic.h
15c15
< syslimits.h
---
> stdnoreturn.h
root@debianxc:~#

Erklärungen:

1) Es werden ed Skripteditor Kommandos aufgelistet, mit denen aus der Datei 1 die Datei 2 wird.

2) Die Zeilen der Datei werden mit 1 zu zählen begonnen.

3) Die Änderungen sind nicht kontextbezogen, d.h. eine Änderung verändert nicht das Bezugsystem für nachfolgende Änderungsmitteilungen.

Wenn z.B. Datei 1 mit 0a1,10 eine Vorspan mit den ersten 10 Zeilen der Datei 2 erhält, dann sind die Zeilenbezüge für die folgenden diff Änderungsmitteilungen immer noch auf die Ausgangslage der Datei 1 bezogen und nicht etwa auf die um 10 Zeilen gewachsene Datei!

4) Es gibt die folgenden Operationen:
m(,n)d - löscht Zeile m (bis n) aus Datei 1

m(,n)cp(,q) - tauscht die Zeile m (bis n) von Datei 1 gegen die Zeile p (bis q) von Datei 2

map(,q) - fügt nach Zeile m von Datei 1 die Zeile p (bis q) an

5) Zeilennummer 0 kommt dann zum Einsatz, wenn man vor der ersten Zeile einen Append machen möchte.   

Unterschied Betriebskosten Heizkosten Nebenkosten Kaltmiete Warmmiete

Meine Meinung geht konform zu diesem Blog: https://nebenkosten-blog.de/definition-der-betriebskosten-nebenkosten/
Betriebskosten: Heizkosten ist Subclass von Betriebskosten.
Nebenkosten = Summe aller Betriebskosten bzw. Menge aller Betriebskosten
aber man sagt auch:

Nebenkosten = Heizkosten +  (sonstige verbliebene Betriebskosten)

Nebenkosten - Heizkosten = Kaltkosten (so im Umgangssprachlichen Gebrauch).

Hier wird Heizkosten als Untergruppe innerhalb der Betriebskosten herausgestellt, da diese spezielle Form der Betriebskosten nicht pauschal (nach einem willkürlichen Umlageschlüssel, welcher nicht bedarfsgerecht sein muss) sondern verbrauchsgerecht umgelegt werden müssen.


Kaltmiete = Grundmiete + Kaltkosten

Warmmiete = Kaltmiete + Heizkosten

Warmmiete = Grundmiete + Kaltkosten + Heizkosten

Warmmiete = Grundmiete + Nebenkosten


Zusatzinfo:

Zur Warmmiete kommt noch der individuelle Stromverbrauch oben drauf.

Endkosten der Wohnung = Warmmiete + Stromkosten (in der eigenen Wohnung)

====================================

ACHTUNG:
Amtsgebrauch bei Grundsicherung macht aber einen Fehler. Sie definieren:

Nebenkosten = "Betriebskosten exklusive Heizkosten"

Also:
Nebenkosten + Heizkosten = Betriebskosten

Linux firewall iptables at a glance

How iptables work


Before we begin, here is the meta-grammar for iptables:

ip tables
table   : filter (default) | nat | mangle | raw | security
filter  : INPUT | FORWARD | OUTPUT
nat     : PREROUTING | OUTPUT | POSTROUTING
mangle  : INPUT | FORWARD | PREROUTING | OUTPUT | POSTROUTING
table   : {chain}+
chain   : {userdefined} | {built-in}
built-in: INPUT | FORWARD | OUTPUT | PREROUTING | POSTROUTING
chain   : {rule}+ 
rule    : {criteria}+ -> {chain | target}
target  : ACCEPT, DROP, QUEUE or RETURN

As you can see, there is the concept of tables. These tables classify the purpose of their containing set of rule chains. All rule chains in table filter have therefore a filter purpose in charge.
Let's explain the firewall processing of IP Packets with an example.
An application on our host generates content to be sent outside via network. Because this is content originating from ourselves, the OUTPUT chain of rules is going to be applied. But this pre-named OUTPUT chain exist in multiple tables in seperate instances. As you can see, the tables filter, nat and mangle all have their own instance of an OUTPUT chain. There is a predefined order between these OUTPUT chains from different tables. Lets say that first the filter.OUTPUT is being processed followed by nat.OUTPUT and finalized by mangle.OUTPUT. Each element in e.g. filter.OUTPUT is a rule, which can terminate with an end status (ACCEPT,DROP,...) or link to another rule in a chain of the current table. If no rule of the running chain has to be processed anymore within the current table, then the next table's chain of the same type is becoming running.
Long story short: Packets get processed by first checking their orginating source and target ip and based on that the appropiate chain gets selected. Multiple instances of this chain can be located in multiple tables. Each of this chain instances will be processed one by one. So the first chain instance must be finished before the next instance can start.
We also must consider that not every chain getting processed has multiple instances in each table.
After one set of chains with the same type (name) is finished, any remaing type of chains suitable for the network traffic gets a run.
.....
An here comes a dump:

[root@localhost ~]# iptables -t filter -L INPUT
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     all  --  anywhere             anywhere             ctstate RELATED,ESTABLISHED
ACCEPT     all  --  anywhere             anywhere
INPUT_direct  all  --  anywhere             anywhere
INPUT_ZONES  all  --  anywhere             anywhere
ACCEPT     icmp --  anywhere             anywhere
REJECT     all  --  anywhere             anywhere             reject-with icmp-host-prohibited

[root@localhost ~]# iptables -t filter -S INPUT
-P INPUT ACCEPT
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -j INPUT_direct
-A INPUT -j INPUT_ZONES
-A INPUT -p icmp -j ACCEPT
-A INPUT -j REJECT --reject-with icmp-host-prohibited
[root@localhost ~]# man iptables
[root@localhost ~]# iptables -I INPUT -s 192.168.1.0/24 -j ACCEPT
[root@localhost ~]# iptables -t filter -S INPUT
-P INPUT ACCEPT
-A INPUT -s 192.168.1.0/24 -j ACCEPT
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -j INPUT_direct
-A INPUT -j INPUT_ZONES
-A INPUT -p icmp -j ACCEPT
-A INPUT -j REJECT --reject-with icmp-host-prohibited