NetzwerkProg. Paket generieren, auffüllen

[Zarathustra]

Es gilt, in Java eine Datei in 64Byte grosse Teile aus byte-Vektoren zu zerlegen.

1.
Aber wenn die Dateigröße nicht Vielfaches von 64 ist, wie fülle ich dann den Rest des Pakets auf, sodaß die Füllzeichen auch wieder aussortiert werden können?

2.
Und wie kann man den Bitstrom analysieren und manipulieren, um den Datenteil des Pakets mit Nullen zu maskieren, um beim Auslesen des Pakets Verwechslungen mit sonstigen Paketinformationen vorzubeugen?
Oder stellt sich das Problem überhaupt nicht, weil evtl. die Dateien Dateisystembedingt automatisch zur vollen Clustergröße aufgefüllt werden?

Thx schonmal! :help:

[Xmas]

1. Darf nicht das letzte Paket kleiner sein? Wenn nicht, musst du die Dateigröße an den Anfang des ersten Pakets setzen und beim Zusammensetzen dann wieder auslesen.

2. Was für Pakete meinst du genau? Was für ein Bitstrom? Welche Tools/Klassen in Java verwendest du?

[Zarathustra]

Ergebnis soll ein "Sliding Window"-Vorgang sein, d.h. es werden erstmal Rahmen (Fenster) vorbereitet, die neben einer Fensternummer usw. einen Datenteil beinhalten, der aus 7 Paketen besteht, die wiederum jeweils nummeriert sind und einen 64Byte grossen Datenteil haben.

Ist ein Fenster fehlerhaft angekommen, wird ab dem unbrauchbaren Paket der betreffende Teil des Fensters nochmals geschickt, ansonsten "rückt" das Fenster weiter und die nächsten 7 Pakete werden in einem Fenster aufgereiht.

Ich lese die Datei mit einem FileInputStream ein.

FileInputStream fileinstream=new FileInputStream(filename);
int dateigroesse=fileinstream.available();

Und dann:

for(7 Pakete durchzählen)
{
int l=(dateigroesse%64);
if((dateigroesse-64*paketnr)<64 && l!=0)
int j=l;
else j=0;

for(; j<64; j++)
{
byte b=fileinstream.read();
daten.add(b);
}//Byteweise einlesen

Paket paket=new Paket(daten, paketnr, fensternr);
rahmen.setPaket(paket);//P. ins Fenster einsetzen
paketnr++;
}
fensternr++;
...

Am Anfang der äusseren for-Schleife, bis kurz vor die innere, ist der Teil, in dem die verbleibende Datenmenge geprüft wird. Dort müsste aufgefüllt werden. Ob das letzte kleiner sein kann, weiss ich grad auch nicht :( . Gehen wir doch bitte vorerst vavon aus, dass dem nicht so ist. ;)

Frage 2 bezog sich auf den Rückweg: wie finde ich verläßlich heraus, was zum auffüllen gebraucht wurde und was zum wiederherzustellenden Datenbestand gehört? Und ist das Bitweise nötig?

Und eine weitere Frage hat sich auch ergeben:
Das byteweise Einlesen in der inneren for-Schleife funktioniert nicht, der Compiler sagt: "cannot resolve symbol: method add(byte) , location: class java.util.Vector". Wo ist das Problem? Ist ein Vector aus bytes nicht möglich? :o


E: Ach ja... das ist sicher noch nicht alles! Im Moment geht es noch eher darum was passiert.

[HellHorse]

Original geschrieben von Zarathustra
Wo ist das Problem? Ist ein Vector aus bytes nicht möglich? :o

Exakt, da man in einen Vector bloss Objekte packen kann und und byte's keine Objekte sind.
Du kannst aber ein byte in ein Byte Objekt verpacken
einVector.add(new Byte(einByte)); sollte gehen

Und brauch keine Vector's sondern entweder LinkedList oder ArrayList :nono: ;)

[clm[k1]]

Hab gerade mal mit wem anders drüber gequatscht:
folgendes hat sich ergeben:

1.) die minimale paket-größe beträgt 64 byte - ergo muss man auffüllen!
2.) das man das aufgefüllte nicht mit in die datei schreibt, erreicht man indem man mit der dateigröße vergleicht!
3.) die dateigröße muss man folglich im ersten paket mit übergeben!
4.) ein fenster muss immer 7 pakete beinhalten!
5.) um also dort auch noch gescheit auffüllen und wieder rekonstruieren zu können muss man die anzahl der fälligen pakete auch im ersten paket mit senden!

eventuell kann oder muss man noch andere daten im ersten paket mit senden, aber das wirste dann ja sehen...

hoffe geholfen zu haben :)


gruß
clm[k1]

[Zarathustra]

Ich wollte keinen Extrathread aufmachen:

Wie oben beschrieben, wurden die daten aus der Datei als Bytes in den Datenteil des Pakets geschrieben.
Nun müssen sie auch wieder da raus...


//Fenster holen, von da Paket holen...
ArrayList daten = paket.getPaketDaten();
for(int j=0; j<64; j++)
{
...daten.get(j); //liefert Object zurueck
//wie mache ich nun aus diesem "Object" ein byte?
byte b= ... ;
fileoutstream.write(b);
}

Ich habe dafür keine Funktion von Byte oder Object gefunden.
Höchstens das hier:

class Byte:
public int compareTo(Object o),
public byte byteValue();

[ethrandil]

Hast es doch schon :)


Byte b = new Byte(55b);
byte realB = b.byteValue();


- Eth

[Zarathustra]

Schau bitte nochmal oben in meinen code:

"daten.get(j)" liefert ein Objectzurück, kein Byte!:asshole:

DAS ist ja eben das Problem :(

[ethrandil]

Original geschrieben von Zarathustra
"daten.get(j)" liefert ein Objectzurück, kein Byte
Dein Zauberwort heißt Casten!

Byte b = (Byte)daten.get(j);

//oder in kurz:
byte realB = ((Byte)daten.get(j)).byteValue();

- Eth

[Zarathustra]

Oha! Casten kenn ich, aber casten zwischen verschiedenen Klassen, warum komme ich auf sowas nicht?:D

Dank dir!

[clm[k1]]

Stellt denn die Klasse des Objektes keine Methode bereit, um wieder an die Daten zu kommen??
ich meine, wenn die klasse ne methode bereit stellt, um die bytes darin unter zu bringen, sollte sie doch auch eine bereit stellen, mit der man die daten / bytes wieder gescheit abrufen kann....


just my 2 cent
clm[k1]

[Zarathustra]

Ne, clm, ich lese die bytes mit daten.add(new Byte(b)); ein, sonst geht auch das nicht.


Nun noch eine Frage:
Da beim (simulierten) routen die Pakete im Fenster durcheinandergeraten sind, muß nun beim wiederherstellen der Datei deren Reihenfolge anhand der Paketnummer erkannt werden.
Dazu muß ich in dem ArrayList, welches das Fenster darstellt, nach einem Element (dem Paket) suchen, welches eine bestimmte Paketnummer hat:


int index = fenster.indexOf(/*hier ist das Problem, s.u.*/);
Paket paket = (Paket) fenster.get(i);

Das Problem:
An der oben markierten Stelle muss ein Object übergeben werden, aber alles was ich habe, ist die zu suchende Paketnummer, welche eine Variable der Klasse Paket ist.

Lässt sich hier mit indexOf() überhaupt arbeiten oder ist das selberschreiben eines Suchalgorithmus unumgänglich? (Wäre nicht sehr elegant.)