# Go Back N



## 0din (6. Okt 2009)

Hallo,

ich suche im mom eine implementierung vom GBN protokol...

Hat jmd evtl. sowas auf Lager?


----------



## tuxedo (6. Okt 2009)

Ähm, wenn man Wikipedia glauben schenken darf dann hast du das mit TCP schon?!



			
				http://de.wikipedia.org/wiki/ARQ-Protokoll hat gesagt.:
			
		

> *Go-Back-N*
> 
> Go-Back-N (engl. für Gehe zu N zurück) stellt ein Verfahren dar, das im Gegensatz zu Stop-and-Wait einen deutlich größeren Durchsatz ermöglicht.
> 
> ...


----------



## 0din (7. Okt 2009)

Stimmt teilweise... TCP is ne mischung aus Slective Repeat und GBN

Nur ich studiere un bin z.Z. innem projekt wobei wir mittels einer UDP sowohl multimedia verschicken und einige wichtige daten (login etc) nich unbedingt verlieren wollen.

Da wir zu dem zeitpunkt ruhig ne etwas höhe last auf dem netz haben können wollten wir GBN ins programm einbaun...


----------



## tuxedo (7. Okt 2009)

MUSS denn alles über UDP gehen? Also "Multimedia" und "Steuerung"?

RTSP verwendet hierfür ja auch TCP in Kombination mit UDP ...

- Alex


----------



## 0din (9. Okt 2009)

Naja, das ganze soll auf nem Handy laufen... un unsere ansprüche warn, so klein un einfach wie möglich... 

Da fand ichs eig ganz sinnig nur eine verbindung zu nehmen un da wir multimedia mit einbaun musses halt UDP sein.

Ich geb die hoffnung auf nen fertiges GBN mal aufgebe, stell ich mal den code rein den ich nu hab un frage dazu mal um hilfe ^^ da komm ich zeitlich wohl doch besser mit zurecht.



Noch is das ganze auf TCP, sobalds gescheit läuft wirds aber auf UDP umgebaut.
(machts testen leichter)

GBN is die eigentliche klasse, die die arbeit machen sollte.

```
package IN23;


public class GBN
{
	//Receiver
	private String inputData;
	private int toAck, acked, ack1, ack2;
	private Sender sender;
	private Receiver receiver;
	private Thread t1, t2;
	
	//Sender
	private String[] data;
	private int sn;
	
	public GBN()
	{
		sender = new Sender(this);
		receiver = new Receiver(this);
		
		t1 = new Thread(sender);
		t2 = new Thread(receiver);
		
		data = this.createData();
	}
	
	public String[] getData()
	{
		return data;
	}
	
	public void setInputData(String inputData)
	{
		System.out.println("GBN krijgt '" + inputData + "' binnen.");
		try
		{
			String[] splitted = inputData.split("°");
			toAck = Integer.parseInt(splitted[0]) + 1;
			sn = Integer.parseInt(splitted[1]);
			this.inputData = splitted[2];
			
			if(ack1 == ack2 && ack1 == sn && ack2 == sn)
			{
				//3 zelfde acks
				//hersturen
				sn = ack1;
			}
			else
			{
				//niets fout, we zijn gelukig en gaan verder
				ack1 = ack2;
				ack2 = sn;
			}		
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		
	}
	
	//deze methode geeft de versturende data
	//dit spaart zoeken als we de data wijzigen willen
	private String[] createData()
	{
		String[] data = new String[8];
		
		data[0] = "Data op 0";
		data[1] = "Data op 1";
		data[2] = "Data op 2";
		data[3] = "Data op 3";
		
		return data;
	}

	
	public int getToAck()
	{
		return toAck;
	}

	
	public void setToAck(int toAck)
	{
		this.toAck = toAck;
	}

	
	public int getAcked()
	{
		return acked;
	}

	public int getSN()
	{
		return sn;
	}
	
	public void setAcked(int acked)
	{
		this.acked = acked;
	}

}
```


Reader is die klasse die als server funktioniert, im eigenen thread also auf eingehende daten wartet.

```
package IN23;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;

public class Receiver implements Runnable
{

	private ServerSocket ss;
	private BufferedReader br;
	private GBN gbn;

	public Receiver(GBN gbn)
	{
		try
		{
			this.gbn = gbn;
			ss = new ServerSocket(8080);
			br = new BufferedReader(new InputStreamReader(ss.accept().getInputStream()));
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}

	private void listening()
	{
		while (true)
		{
			try
			{
				String inhoud;

				while ((inhoud = br.readLine()) != null)
				{
					gbn.setInputData(inhoud);
				}
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
		}
	}

	@Override
	public void run()
	{
		listening();
	}

}
```


un wer häts gedacht, Sender spielt die sendende klasse, die alle daten bzw. Acks raus geben soll.

```
package IN23;

import java.io.DataOutputStream;
import java.net.Socket;


public class Sender implements Runnable
{
	private GBN gbn;
	private DataOutputStream dos;
	private String[] data;
	private int snNew;
	
	public Sender(GBN gbn)
	{
		this.gbn = gbn;
		try
		{
			dos = new DataOutputStream(new Socket("localhost", 8080).getOutputStream());
			data = gbn.getData();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	
	public void sendData()
	{
		snNew = gbn.getSN();
		for(String st : data)
		{
			try
			{
				dos.writeBytes(snNew + gbn.getToAck() + st);
				snNew += 1;
			}
			catch (Exception e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		
	}

}
```

Nun laufe ich nur gegen 2 Probleme,
das erste ist das SendingWindow und das aufschieben
das zweite das ReceivingWindow un das aufschieben... 

Theoretisch weiß ich wie das ganze funktioniert aber sobal das ganze in Code soll... Bhf...
Hat jmd vllt nen vorschlag wie man das aufschieben machen könnte?


----------

