Keskustelu: Ohjelmointikysymykset: C++: Pakettien jakaminen megoiksi

   char memData[1024];

   ifstream inStream("testikuva.bmp", ios_base::in|ios_base::binary);

    if (!inStream.is_open()) return 1008; else{



   while( !inStream.eof() ){
     inStream.read(memData, 1024);

  send ( sd.fd, memData, sizeof(memData), 0 );

    inStream.seekg(1024, ios_base::cur);

  }
}
   inStream.close();

while(loop){
  string data = "";
  bool suor = false;

     //Luodaan kirjotettava tiedosto
     ofstream so("testikuva2.bmp", ios_base::binary);

  //Hetaan data "data" muuttujaan
   data = Get(0);

   //Jos "suor" on true
    if( suor ){
     //Eli silmukka tiedoston siirron ajan... :)
     //Silmukka pyörii niin kauan, kunnes saa käsiinsä komennon "LOPPU!" jolloin "suor" muuttuu falseksi.
     while( suor ){
      data = Get(0);
       if( data == "LOPPU!" ) suor = false; else{
       so.write((char*)data.c_str(), data.length());
       cout << "[" << data << "]" << endl;
       }
     }

    }

    if( data == "ALKAA!"){
     cout << "OK!" << endl;
     suor = true;
    }

     //Tiedosto siiretty onnistuneesti suljetaan kirjoitus.
    if( data == "LOPPU!"){
     cout << "Tiedosto valmis!" << endl;
     suor = false;
     so.close();
    }
}

if(suor){
    string data = "", komento = "";
    int koko = 0;


 ofstream so("testikuva2.bmp", ios_base::binary);

  while( suor ){
    data = Get(0);
  istringstream ist(data);
  ist >> komento;
  ist >> koko;
   if( komento == "tiedosto" ){
    cout << data << endl;

   if(data.length() > sizeof("tiedosto 1024"))
    data = data.substr(sizeof("tiedosto 1024"), data.length());

    for (int i = 0; i < koko; i += data.length()) {

      data = data.substr(0, koko - i);
      so.write(data.c_str(), data.length());
    }


   }
   if( komento == "" ){
    suor = false;
    cout << "Tiedosto siiretty!" << data << "]" << endl;
   }
}

 so.close();
}

#include <sstream>
#include <fstream>
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>

using namespace std;

// ei tarvitse koodiin osoitinmuunnoksia kirjoitella... ;)
// X *px = any_ptr(&mika_vain);
class any_ptr {
	void *ptr;
public:
	any_ptr(void *_ptr): ptr(_ptr) {}
	template <typename T> operator T* () { return (T*) ptr; }
};

int sock;
sockaddr_in addr = {0};

// lukee socketista dataa tietyn tavumäärän (odottaa, että tulee tarpeeksi)
string hae_dataa(int koko) {
	string rivi;
	char buf[1024];
	while (koko > sizeof(buf)) {
		recv(sock, buf, sizeof(buf), 0);
		rivi += string(buf, sizeof(buf));
		koko -= sizeof(buf);
	}
	recv(sock, buf, koko, 0);
	rivi += string(buf, koko);
	return rivi;
}

// lukee rivin dataa (tavu kerrallaan, kunnes tulee \n)
string hae_rivi() {
	string rivi;
	do {
		rivi += hae_dataa(1);
	} while (*rivi.rbegin() != '\n');
	return rivi;
}

// lähettää datan
void laheta_dataa(string data) {
	send(sock, data.c_str(), data.length(), 0);
}

// hoitaa kommunikaation
/**
 * lue koe.cpp
 *  - lukee pyydetyn tiedoston (esim. koe.cpp) ja lähettää tallenna-rivin
 * tallenna koe.cpp X
 *  - tätä riviä seuraa X tavua raakaa dataa
 * viesti Moi, Petteri!
 *  - tulostaa viestin vastapuolella
 * loppu
 *  - sulkee vastapuolen ohjelman
 * Data liikkuu muuten rivi kerrallaan (päättyy \n-merkkiin), mutta
 * tiedosto siirretään yhtenäisenä binaaripalikkana kesken kaiken.
 */
void kommunikoi() {
	string data, komento, viesti, nimi;
	fstream tiedosto;
	int koko, i;

	while (true) {
		// luetaan rivi dataa
		data = hae_rivi();
		istringstream ist(data);
		ist >> komento;
		if (komento == "lue") {
			// luetaan pyydetty tiedosto ja lähetetään
			ist >> nimi;
			tiedosto.open(nimi.c_str(), ios::in | ios::binary);

			// selvitetään koko
			tiedosto.seekg(0, ios::end);
			koko = tiedosto.tellg();
			tiedosto.seekg(0, ios::beg);

			// lähetetään otsikkorivi ("tallenna tiedostonimi koko")
			ostringstream ost;
			ost << "tallenna " << nimi << " " << koko << endl;
			laheta_dataa(ost.str());

			// lähetetään dataa 1024 tavun paketeissa
			char buf[1024];
			while (koko > sizeof(buf)) {
				tiedosto.read(buf, sizeof(buf));
				laheta_dataa(string(buf, sizeof(buf)));
				koko -= sizeof(buf);
			}
			tiedosto.read(buf, koko);
			laheta_dataa(string(buf, koko));

			// suljetaan tiedosto
			tiedosto.close();
		} else if (komento == "tallenna") {
			// vastaanotetaan tiedosto ja tallennetaan se
			ist >> nimi >> koko;
			tiedosto.open(nimi.c_str(), ios::out | ios::binary);
			tiedosto << hae_dataa(koko);
			tiedosto.close();
		} else if (komento == "viesti") {
			// tulee viesti; otetaan alusta välilyönti pois ja tulostetaan loput
			ist.get();
			getline(ist, viesti);
			cout << viesti << endl;
		} else if (komento == "loppu") {
			// vastataan samalla mitalla ja suljetaan ohjelma
			laheta_dataa(data);
			break;
		} else {
			// ilmoitetaan tuntemattomasta komennosta
			cout << "Virheellinen rivi: " << data;
		}
	}
}

int main(int argc, char **argv) {
	sock = socket(AF_INET, SOCK_STREAM, 0);
	addr.sin_family = AF_INET;
	// porttinumero: 1234x, x otetaan komentoriviparametrina
	addr.sin_port = htons(12340 + argv[1][0] - '0');
	inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
	connect(sock, any_ptr(&addr), sizeof(addr));

	kommunikoi();

	close(sock);
}

case FD_WRITE:

 while(true){

  if(!protocol.canSend){
   if( send(wParam, "", 1024, 0) == SOCKET_ERROR ){
      break;
   }
  }else{
    if(protocol.tSend(wParam) == 1200){
     break;
    }
  }



 }


break;

 int PROTOCOL::tSend(WPARAM wParam){
      char buf[1024];
      string numma = "";
       ostringstream ost;
       string pData = "";

 if(koko <= 0 && PROTOCOL::canSend){
   tiedosto.open("dd.bmp", ios::in | ios::binary);
            tiedosto.seekg(0, ios::end);
            koko = tiedosto.tellg();
            tiedosto.seekg(0, ios::beg);

   send(wParam, "Tallenna", sizeof(buf), 0);
   //MessageBox(NULL, strKoko.c_str(), "Koko", 0);
 }

  while( koko > sizeof(buf) ){
  tiedosto.read(buf, sizeof(buf));
  //sprintf(buf, "%d\n", koko);
  //numma = buf;

    if(send(wParam, buf, sizeof(buf), 0) == SOCKET_ERROR){
    // MessageBox(NULL, "Paina Send uudelleen!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
      tiedosto.seekg(kokoI, ios::beg);
      if (WSAGetLastError() == WSAEWOULDBLOCK){
       //ost << "Piste: " << tiedosto.tellg() << endl;
      // numma = ost.str();
       //MessageBox(NULL, numma.c_str(), "Ilmoitus", MB_OK|MB_ICONINFORMATION);
       return 1200;
      }else{
       MessageBox(NULL, "Joku virhe!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
      }
    }else{

     //sprintf(buf, "%d", koko);
     //MessageBox(NULL, buf, "Ilmoitus", MB_OK|MB_ICONINFORMATION);

     koko -= sizeof(buf);
     kokoI += sizeof(buf);
     //if(numma.substr(0, 4) == "1910") MessageBox(NULL, "Jummausta vaan!", "Jummaa!", 0);
    }
  }

  if(koko > 0 && koko < sizeof(buf) && PROTOCOL::canSend){
  tiedosto.seekg(kokoI, ios::beg);
  tiedosto.read(buf, koko);
  //sprintf(buf, "%d\n", koko);
    //sprintf(buf, "%d\n", koko);

  pData = string(buf, koko);

    if(send(wParam, pData.c_str(), sizeof(buf), 0) == SOCKET_ERROR){
     //return 1200;
      if (WSAGetLastError() == WSAEWOULDBLOCK){
       //MessageBox(NULL, "Paina Send uudelleen!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
       return 1200;
      }else{
       MessageBox(NULL, "Joku virhe!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
      }
    }else{

     tiedosto.close();
     PROTOCOL::canSend = false;
     koko -= sizeof(buf);
     kokoI += sizeof(buf);
     tiedosto.seekg(kokoI, ios::beg);
     sendOk = true;
    }
  }

  if(sendOk)
       if(send(wParam, "OK", sizeof(buf), 0) == SOCKET_ERROR){
      if (WSAGetLastError() == WSAEWOULDBLOCK){
       //MessageBox(NULL, "Paina Send uudelleen!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
       return 1200;
      }else{
       MessageBox(NULL, "Joku virhe!", "Ilmoitus", MB_OK|MB_ICONINFORMATION);
      }
      //return 1200;
      sendOk = false;
     }

  //send(pm.socket, "lopeta", sizeof(buf), 0);
      delete [] buf;

  return 1;
}

/*
class PROTOCOL {
  private:
    std::deque<std::string> jono;
    int sock;
  public:
    void sendData(const char *data, int length);
    void sendData(std::string);
    void trySend();
};
*/
// Tehdään funktiot datan lähetykseen. Nämä lisäävät datan jonoon ja yrittävät lähettää jonosta dataa.
void PROTOCOL::sendData(const char *data, int length) {
  sendData(std::string(data, length));
}
void PROTOCOL::sendData(std::string data) {
  // Lisätään jonoon.
  jono.push_back(data);
  // Jono muuttui, yritetään lähettää.
  trySend();
}

// Funktio, joka yrittää lähettää dataa:
void PROTOCOL::trySend() {
  // Kun jonossa on lähetettävää
  while (!jono.empty()) {
    std::string data = jono.front();
    int length = data.length();
    int ret = send(sock, data.data(), data.size(), 0);
    if (ret == data.size()) {
      // Data meni, otetaan se pois jonosta ja jatketaan.
      jono.pop_front();
      continue;
    }
    ret = WSAGetLastError();
    if (ret == WSAEWOULDBLOCK) {
      // Data ei mennyt, lopetetaan yritys ja odotetaan FD_WRITE-viestiä.
      return;
    }
    if (ret == WSAEMSGSIZE) {
      // Viesti on liian iso, katkaistaan puoliksi ja laitetaan palat jonoon.
      jono.front() = data.substr(data.size() / 2);
      jono.push_front(data.substr(0, data.size() / 2));
    }
  }
}

// Lähetetään tekstiä:
protocol.send("OK\n");

// Viestin tullessa yritetään lähettää dataa. Funktio tietää, oliko lähetettävää ja menikö kaikki.
case FD_WRITE:
  protocol.trySend();
  break;