Problem mit send();

Also, send() kann ja bekannterweise -1 oder die Anzahl gesendeter Zeichen zurückgeben...

Ausschnitt des Programmes:

string lol("Ich bin ein über sinnloser Text der vieleicht versendet wird");
int irc = -1;

irc = send(sende_socket,lol.c_str(),lol.size(),0);

if(irc < lol.size()){
cout << "Nicht genug Zeichen gesendet" << endl;
}if(irc == -1){
cout << "Konnte Zeichen nicht senden" << endl;
return ;
}

Soo und nun meine Frage:
Was ist wenn

irc < lol.size()

ist (das bedeutet das weniger Zeichen gesendet wurden als lol.size() is klar)
aber welche Zeichen wurden jetzt gesendet?

Vieleicht ist es so:

//gesendete Zeichen:
string gesendeteZeichen = lol.substr(0,irc);

ist es so?
wenn ja könnte man dieses Problem ja ziemlich einfach lösen
wenn nicht dann müßte mein Server das Packet verwerfen und auf eins mit einer richtigen Größe warten....

Danke im voraus

cout << "mfg" << endl;
cout << "pf" << endl;

Badestrand

pfUrz schrieb:

Was ist wenn
irc < lol.size()
ist (das bedeutet das weniger Zeichen gesendet wurden als lol.size() is klar)
aber welche Zeichen wurden jetzt gesendet?

Vieleicht ist es so:
//gesendete Zeichen:
string gesendeteZeichen = lol.substr(0,irc);
ist es so?

Ja, das heißt dann, dass nur die ersten irc Bytes gesendet werden konnten

Gegenfrage: Warum schreibst du eigentlich nicht gleich int irc = send(... , sondern verteilst es auf 2 Zeilen?

Keine Ahnung einfach so

ne also steht der Returnwert für die ERSTEN gesendeten Zeichen?

wenn ja dann danke

tenchou

ja so ist es

Cool danke ich habe das jetzt so gelöst:

//by pfUrz @ www.c-plusplus.net
    string msg("Ich bin ún String der mit der string klasse erstellt wurde ....");
    string substring("");
    int irc = 0;

    irc = send(sock,msg.c_str(),msg.size(),0);
    if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
    if(irc < msg.size()){
        while(irc < msg.size()){
            substring = msg.substr(irc,msg.size());
            msg = substring;
            irc = send(sock,msg.c_str(),msg.size(),0);
            if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
        }
    }
    cout << "Alles wurde erfolgreich gesendet! :D" << endl;

Badestrand

//by Badestrand @ www.c-plusplus.net
    string msg("Ich bin ún String der mit der string klasse erstellt wurde ....");

    int irc = send(sock,msg.c_str(),msg.size(),0);
    if(irc == -1){cout << "error send() returned -1" << endl;return 0;}

    if ( irc < msg.size() ){
        const char* tosend = msg.c_str() + irc;
        const char* end = msg.c_str() + msg.size() + 1;
        while ( to_send < end ) {
            irc = send( sock, tosend, end-tosend /* +1? */, 0 );
            if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
            tosend += irc;
        }
    cout << "Alles wurde erfolgreich gesendet! :D" << endl;

So gehts auch, fällt das wiederholte substr weg

edit: So sollte es auch gehen, ist ungetestet!

meins geht nicht??

Badestrand

doch doch

Cool danke für die Hilfe Leute(@Badestrand , tenchou )

schönen Abend noch

mit freundlichen Grüßen pfUrz.

Oh verdammt hab noche einmal drüber geschlafen so hier ist mein Code richtig:

//by pfUrz @ www.c-plusplus.net
    string msg("Ich bin ún String der mit der string klasse erstellt wurde ....");
    string substring("");
    int irc = 0;

    irc = send(sock,msg.c_str(),msg.size(),0);
    if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
    if(irc < msg.size()){
        while(irc < msg.size()){
            substring = msg.substr(irc,msg.size()-irc); // -irc vergessen :-)
            msg = substring;
            irc = send(sock,msg.c_str(),msg.size(),0);
            if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
        }
    }
    cout << "Alles wurde erfolgreich gesendet! :D" << endl;

bitte nimm den Code von Badestrand. deiner ist echt übel

rüdiger

bool mysend(int socket, char const *str, std::size_t size, int flags = 0) {
  assert(str);
  std::size_t offset = 0;
  while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;
  }
  return true;
}

bool mysend(int socket, std::string const &str, int flags = 0) {
  return mysend(socket, str.c_str(), str.size(), flags);
}

// ...
if(mysend(sock, str))
  std::cout << "alles in Ordnung\n";
else
  std::cerr << "upsi. Fehler\n";

so würde ich das schreiben. (ungetestet)

Joar danke @rüdiger dein Code sieht gut aus und ich verstehe ihn auch
aber solange ich auch meinen Code verstehe und er funktioniert (ja er funktioniert tatsächlich^^)
werd ich meinen Code verwenden

danke @ all

schön NachMittag noch

mfg ich

EOP

rüdiger schrieb:

bool mysend(int socket, char const *str, std::size_t size, int flags = 0) {
  assert(str);
  std::size_t offset = 0;
  while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;
  }
  return true;
}

bool mysend(int socket, std::string const &str, int flags = 0) {
  return mysend(socket, str.c_str(), str.size(), flags);
}

// ...
if(mysend(sock, str))
  std::cout << "alles in Ordnung\n";
else
  std::cerr << "upsi. Fehler\n";

so würde ich das schreiben. (ungetestet)

Ich nicht, da size_t als unsigned int definiert ist und somit nie < 0 werden kann, wirst du bei einem socket error ruckzuck ein problem bekommen.

int offset = 0;
int bytes_to_send = (int) strlen( str );
while( bytes_to_send > 0 )
{
	int bytes_sent = send( sock, str+offset, bytes_to_send, 0 );
	if( bytes_sent == -1 )
		return( false );
	else
	{
		bytes_to_send -= bytes_sent;
		offset += bytes_sent;
	}
	return( true );
}

rüdiger

@EOP
offset soll ja auch nicht kleiner als 0 werden! Das wäre ein fataler Fehler. int ist dagegen die falsche Wahl, da size_t größer als int sein kann. Dann endet man mit Überläufen. (bzw. schon für alle Werte, die größer sind als std::numeric_limits<int>::max und das ist bei unsigned vs signed ja nicht schwierig).

EOP

@rüdiger
:
ich meinte auch nicht offset sondern natürlich dein ret:

ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)

sollte ja wohl size_t ret heissen?

int ist die falsche Wahl, wenn nur int erlaubt ist?
Deklaration von send:
int send( SOCKET s, const char* buf, int len, int flags );

EOP

while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;

Was macht dein code wenn beim ersten Versuch -1 (unsigned 0xFFFFFFFF) zurückgegeben wird?
Er addiert ret (0xFFFFFFFF) zum string und bekommt eine Zugriffsverletzung...

rüdiger

ne, das soll schon ssize_t heißen. Das s steht für signed.

ssize_t send(int s, const void *msg, size_t len, int flags);

Siehe POSIX Standard.

rüdiger

EOP schrieb:

while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;
Was macht dein code wenn beim ersten Versuch -1 (unsigned 0xFFFFFFFF) zurückgegeben wird?
Er addiert ret (0xFFFFFFFF) zum string und bekommt eine Zugriffsverletzung...

Wenn -1 zurück gegeben wird, dann gibt er false zurück. Selbst wenn es einen Overflow gäben könnte, dann würde vorher offset < size geprüft werden