Socket-Server soll mehrere Clients akzeptieren!!!

Wenn ich Red Skall richtig verstanden habe, hat er unrecht. Wenn jetzt zum Beispiel eine lange Datenbankoperation ausgeführt wird, kann während dieser Zeit nichts anderes gemacht werden, auch dein OnReceive wird nicht ausgeführt. Es sei denn du benutzt halt Threads.

Unix-Tom

Verwechselt da mal was nicht.
CAsyncSocket baut auf callbacks auf. Aus diesem Grund sind sie Async. Dh es wird etwas an den Socket übergeben und dann weitergemacht. Man wird dann von Socket beachrichtigt wenn sich was getan hat (Mal alles vereinfacht. Nicht der Socket benachrichtig)
Die eigentliche Dialogklasse ist nur ein Thread.
Will man da was pro Client abarbeiten braucht man Threads die unabhängig von der Dlg-Klasse (DLG-Thread) sind.

Wenn ich euch richtig verstehe, muss ich also doch mit Threads arbeiten und jedem Client einen zuordnen. Jeder dieser Threads durchläuft dann alle Funktionen und schließt die Verbindung zwischen Client und Server am Ende oder?
Mfg

Wenn man CAsyncSocket benutzt braucht man für den Netzwerkcode keine zusätzlichen Threads!
Für Datenbankabfragen oder andere zeitaufwendige Dinge braucht man aber zusätzliche Threads da sonst alles geblockt wird.

Wenn du nur mit ein paar Clients rechnest kannst du der Einfachheit halber für jeden Client einen Thread erstellen und dann z.B. CSocket darin benutzen. Aber wenn dein Server viele Clients erwartet ist das eine sehr schlechte Lösung.

Wie ich anfangs schon sagte ich habe mich in diesen Bereich neu eingelesen und diese ist mein erstes Prog mit multitasking.
Deshalb wäre es super wenn du es ein wenig erklären könntest.
Was heisst viele Threads und wie würde die andere Lösung aussehen.
Mfg

Red Skall

omg, ich dachte bisher das CAsyncSocket auf threads aufbaut !! danke, das ihr mich eines besseren belehrt habt !!!!! das war wichtig für mich

Red Skall
ich habe noch mal eine Frage zu deinem Code.

// m_sListenSocket ist objekt von CMySocket 
    if (m_sListenSocket.Accept(*((CMySocket*) oData[m_cConnData.GetSize() -1]))) 
    { 
    }

Was ist m_cConnData ,wofür wird es benutzt und wie wird es deklariert.
Ich habe bis jetzt den nachfolgenden Code benutzt und es klappt auch, deswegen habe ich diese Frage nicht sofort gestellt.

if (m_sListenSocket.Accept(*((CMySocket*) oData[oData.GetSize() -1]))) 
    { 
    }

Aber es interessiert mich schon was der unterschied ist.
Mfg

Red Skall

also das beispiel finde ich programmiertechnisch sowieso etwas umständlich. der ist schon etwas älter, jetzt würde ich das so machen:

OnSocket_Accept()
{
	CMySocket	 *mCurSock = new CMySocket();

	m_oData.Add(mCurSock);

	if (m_sListenSocket.Accept(*mCurSock))
	{
		// weiter machen ...
	}
}

da haste dieses gewusel nicht mehr drin

ich bin mir nicht mal mehr ganz sicher was 'm_cConnData' genau war ^^ denke das sollte 'm_oData' gewesen sein o.ä.

EDIT:
aber das mit dem threads würde ich auch gerne noch wissen. habe eben meine anwendung getestet. da kommt auch nichts an, wenn socket eine funktion aufgerufen hat und diese noch nicht abgearbeitet ist. callback halt -.-

würde nur gerne wissen wie man die sockets in einem eigenen thread ablaufen lässt. (wahrscheinlich wieder mal einfach als ich mir das vorstelle)

Danke klappt auch und sieht viel besser aus.
Wenn ich mich recht erinnere würdest du dann jedem eine ID zuordnen.
Wahrscheinlich im Abschnitt "weiter machen" oder ?

OnSocket_Accept() 
{ 
    CMySocket     *mCurSock = new CMySocket(); 

    m_oData.Add(mCurSock); 

    if (m_sListenSocket.Accept(*mCurSock)) 
    { 
        // weiter machen ... 
// Würdest du das dann so machen?
static int nCounter;
++nCounter;
mCurSock->m_iID = nCounter;
// oder wie ?
    } 
}

Red Skall

- leg dir einfach eine membervariable in deinem dialogfeld an, z.B. int iLastID.

- im contruktor deines dialogfeldes setzt du diese auf 0

jetzt in OnAccept():

// ...
// weiter machen ...

mCurSock->iID = iLastID ++;

jetzt bekommt jeder client ne andere id.

das mit der id ist nur nen vorschlag. das must du selber entscheiden. je nach anwendung würde ich das anders machen. aber irgendetwas, was deinen client eindeutig identifiziert solltest du drin haben.

@Unix-Tom: kannste mal nen beispiel posten wie das mit den threads aussieht? thx

Wofür noch eine ID? Den Socket Descriptor kann man doch zur Identifikation benutzen.

Hier gibts noch Beispielanwendungen, vielleicht hilft es ja: http://tangentsoft.net/wskfaq/examples/basics/index.html

Red Skall

danke fürs beispiel.

ich habe mir das hier genauer angeschaut: http://tangentsoft.net/wskfaq/examples/basics/threaded-server.cpp

aber jetzt bin ich mir unsicher:

ich benutze in meinem programm für jeden client ein socket von CAsyncSocket.
wenn ich threads einbaue, muss ich 'manuell' über Receive() gucken ob daten angekommen sind und ggf. behandeln.

CAsyncSocket tut doch aber das gleiche, dann ist es doch doppelt gemoppelt, oder nicht?

Red Skall
Leider kann ich dir deine Frage nicht beantworten(weiss es selbst nicht).
Wäre aber coll wenn jemand dafür eine Lösung hat.

Ich habe aber noch ein Problem mit OnReceive.
Wenn ich in Accept alle Client annehme und ihnen eine Id zuweise wie kann ich in OnReceive heraus finden welcher Client mit gerade etwas sendet.
Also wie müsste ich folgende Zeile aus dem Prog vom Buch Visual C++ in 21 Tagen ändern damit es funktioniert.

// Nachricht empfangen
  iRcvd = m_sConnectSocket.Receive(pBuf, iBufSize);
  // Haben wir etwas empfangen?
  if (iRcvd == SOCKET_ERROR)
  {
  }
  else
  {
    // Ende der Nachricht abschneiden
    pBuf[iRcvd] = '\0';
    // Nachricht in einen CString kopieren
    strRecvd = pBuf;
    // Nachricht in Listenfeld Empfangen eintragen
    m_ctlRecvd.AddString(strRecvd);
    // Variablen mit Steuerelementen synchronisieren
    UpdateData(FALSE);
  }

m_sConnectSocket habe ich nach dem neuen Code ja nicht mehr sondern sie alle im ObArray gespeichert.
Ich hoffe du verstehst mein Problem.
Mfg

Red Skall

deine OnReceive funktion im dialogfeld sieht jetzt so aus:

void CDlgKlasse::OnReceive()
{
}

vielleicht wird da noch ein errorcode übergeben, so genau habe ich das beispiel nicht mehr im kopf.

die funktion änderst du jetzt folgendermaßen:

void CDlgKlasse::OnReceive(CMySocket *mSock)
{
}

in deiner socketklasse rufst du die funktion deines hauptdialogfeldes nicht mehr ohne parameter auf, sondern so:

void CMySocket::OnReceive()
{
    m_DialogfeldKlasse->OnReceive(this);
}

jetzt wird die adresse vom socket übergeben, der etwas enpfängt. im hauptdialog kannst du die id einfach aus dem übergebenen objekt deiner socket klasse entnehmen.

In der Receive funktion mache ich dann folgendes:

char *pBuf = new char[1025];
	int iBufSize = 1024;
	int iRcvd;
	CString strRecvd;
// Nachricht empfangen
	iRcvd = mSock->Receive(pBuf, iBufSize);

Doch das gibt Problem mit dem Aufruf

GetDocument()

denn ich später in OnReceive aufrufe.
Woran kann das liegen?
bzw.
Wie hast du das mit der Funktion:

// Nachricht empfangen
	iRcvd = mSock->Receive(pBuf, iBufSize);

gelöst?
Mfg

Unix-Tom

Bau mal eine Anwendung welche nur Sockets hat. Diese dann so das sie viele Clients akzeptiert.
Du wirst dann sehen das in deiner Hauptklasse immer eine Funktion aufgerufen wird wenn Daten kommen.
Diese Daten kannst du verarbeiten. Während dieser Verarbeitung wird deine Hauptklasse aber nicht mehr Informiert das Daten kommen bis die Verarbeitung fertig ist.
Jetzt muss Du dir was einfallen lassen um diese Verarbeitung in einen Thread auszulagern um deine Hauptklasse wieder frei zu machen.

Thread starten gibt es genug in der FAQ.
Du startets einen Thread und übergibst ihm das was über den Socket gekommen ist.
Dieser Thread verarbeitet und beendet sich wieder. Vielleicht auch noch den Aufrufer informieren darüber denn wenn du das Programm beendest bevor alle Threads beendet sind hast du ein Problem wenn du die einfach abschießt.
Auch kann sich ja in der Zwischenzeit der Client disconnecten.
Dh also du musst dir was einfallen lassen um die Threads auch zu steuern.
DIeses Thema ist aber ein anderes als CAsyncSocket.
CAsyncSocket heißt nur das die Socketfunktionen nicht blockierend sind und sofort wieder zurückkehren und ein Thread im Hintergrund den Rest für dich erledigt.

würde das gerno so lösen:

es wird etwas empfangen, normalerweise wird jetzt OnReceive() der dialogklasse aufgerufen.

statt dessen starte ich einen thread, aus der ich dann OnReceive() der dialogklasse aufrufe. theoretisch müsste OnReceive dann innerhalb des threads aufgerufen werden. während der abarbeitung der funktionen von OnReceive() können dann mehrere aufrufe dieser funktion von anderen sockets aufgerufen werden, ohne das es störungen geben würde.

jeder socket startet dann ja auch nur den thread und kann sich wieder auf das empfangen von nachrichten konzentrieren.

das müsste doch so möglich sein, oder ?

Unix-Tom

Möglich ist alles. Warum versuchst du es nicht einfach ob du mit Threads klar kommst und auch Sync kannst.