Problem mit send();

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