[C] multi client connecties op server

[Verwijderd]

Ik ben bezig een single-client server om te schrijven naar een multi-client server en vraag me af of ik op de goede weg zit. De originele code was als volgt (vereenvoudigd):

*****
int sockfd;

void init()
open socket;
bind;
listen;
sockfd = accept;
pthread_create(&thread, handle_client);

void handle_client()
ret = write(sockfd, buffer, buflen);
*****

De nieuwe server heb ik nu als volgt, en mijn belangrijkste vraag is als volgt: sockfd was in de oude server als globale variabele gedefinieerd, maar dit kan neem ik aan niet omdat elke client zijn eigen socket krijgt. Wat is dan de makkelijkste oplossing? Nu geef ik de socket constant als paramter mee:

*****
void init()
pthread_create(&child,listen);

void listen()
int sockfd;
open socket;
bind;
listen;
for ;; { sockfd = accept; pthread_create(&thread, handle_client, sockfd; }

void handle_client(int sockfd)
ret = write(sockfd, buffer, buflen);
*****

Maar ik weet niet hoe het precies met threads zit; is het mogelijk om zoiets als een globale variable binnen de thread te definieren zodat ik niet de socket als parameter mee hoef te geven aan alle procedures die binnen de thread worden aangeroepen?

[ACM]

Op maandag 22 juli 2002 12:06 schreef zeronegative het volgende:
Maar ik weet niet hoe het precies met threads zit; is het mogelijk om zoiets als een globale variable binnen de thread te definieren zodat ik niet de socket als parameter mee hoef te geven aan alle procedures die binnen de thread worden aangeroepen?

Sterker nog, alle variabelen die buiten de scope van de methode zitten zijn in principe globaal bij threads.
Maar met een methode kan je natuurlijk geen variabelen meer definieren _buiten_ de methode, die moeten dus wel van te voren gedefinieerd zijn.
Dat ze globaal zijn, is zowel een voor- als een nadeel (mutual exclusiveness moet je expliciet op letten)

[Verwijderd]

Goed, dus het wordt dan:

void init()
pthread_create(&child,listen);

void listen()
int sockfd;
open socket;
bind;
listen;
for ;; { sockfd = accept; pthread_create(&thread, handle_client, sockfd; }

void handle_client(int sockfd)
int socket;
socket = sockfd;
testwrite(buffer);

waarbij testwrite() zelf write(socket, buffer, buflen) aanroept (socket wordt dus als globale variabele gezien). Hm, dat zou inderdaad een stuk makkelijker zijn dan 100 procedure-headers aan lopen passen

[ACM]

Pas op dat dan niet _alle_ threads naar dezelfde socket schrijven!
Daarom stopte de eerste implementatie het waarsch in een aparte methode.

[Verwijderd]

Ik krijg bij elke subprocedure -in dit geval bij testwrite()een bericht dat 'socket' niet gedefinieerd is; hij wordt dus blijkbaar niet globaal doorgegeven. Ook met het declareren van een "external int socket" in de testwrite()
procedure gaat het bij het compilen niet goed.

(Overigens heb ik de variable uiteraard niet echt socket genoemd, aangezien dit een nameclash met de procedure zou opleveren.)

Enig idee?

---

void init()
pthread_create(&child,NULL,listen,NULL);

void listen()
sockfd=socket;
bind;
listen;
for ;; {
newsockfd=accept(sockfd);
pthread_create(&thread,NULL,(void*)handle_client,(void*)newsockfd);
}

void *handle_client(void *newsockfd)
int sockfd = (int) newsockfd;
testwrite(buffer);

void testwrite(char* buffer)
write(sockfd,buffer,buflen); <--- unknown declaration

[Verwijderd]

voorkom globalen zoveel je kunt .. .

in jou geval zou ik een struct maken met alles erin . .. (soort klasse . . maar dan in C ipv C++)

[farlane]

<hier stond bollox>

Als je al die functies in dezelfde source hebt staan, en je socket variabele globaal gedeclareerd moet iedere functie deze kennen.

[Verwijderd]

Skizmo: ik wil geen gewone globale variabele (want dat gaat inderdaad fout), maar eigenlijk een thread-'globale' variable. M.a.w.: hoe kan ik een variabele doorgeven naar procedures en andere threads die aangeroepen worden vanuit de hoofd-thread, zonder dat ik ze als argument mee hoef te geven...

Het probleem zit namelijk hierin, dat de thread een procedure aanroept, en deze roept weer een andere procedure aan, etc etc; als ik alle procedures aan moet passen om de variable telkens als argument te accepteren en door te geven dan kost me dat vrij veel uitpluiswerk; als de variabele eenmaal gedefinieerd zou kunnen worden en vervolgens door alle procedures bereikt kan worden zou dat natuurlijk veel makkelijker zijn.

Zou je struct-oplossing hierbij werken, en zo ja, hoe zie je dit precies?


farlene: als ik een globale variabele in de c-file zou gebruiken, dan zou elke thread deze variabele met z'n eigen waarde overschijven, en dat is nou net wat ik niet wil; ik wil dat elke thread zijn eigen (gelijknamige) variable in z'n eigen memory space heeft.

[farlane]

De VC++ compiler ondersteunt Thread Local Storage. Ik heb er zelf nooit mee gewerkt, maar misschien dat dat wat voor je is?

thread
Microsoft Specific >

__declspec( thread ) declarator

Thread Local Storage (TLS) is the method by which each thread in a given multithreaded process allocates storage for thread-specific data.

The thread extended storage-class modifier is used to declare a thread local variable. The thread attribute must be used with the __declspec keyword.

The use of __declspec(thread) may interfere with delay loading of DLL imports.

For related information, see __declspec.

Example

The following code declares an integer thread local variable and initializes it with a value:

// Example of the thread attribute
__declspec( thread ) int tls_i = 1;
See Also Thread Local Storage (TLS)

END Microsoft Specific

[XTerm]

Hm, MS specific stuff is niet echt aan te raden, portability enzo

Maar waaroml hoeft het een probleem te zijn om data mee te geven als argument ? Maak gewoon een struct* waar alles in zit.

Verder worden dit soort zaken (IPC) ook uitvoerig uitgelegt op deze site.
[url="http://www.cs.cf.ac.uk/Dave/C/"]http://www.cs.cf.ac.uk/Dave/C/[/url]

[Verwijderd]

Op dinsdag 23 juli 2002 10:20 schreef zeronegative het volgende:
farlene: als ik een globale variabele in de c-file zou gebruiken, dan zou elke thread deze variabele met z'n eigen waarde overschijven, en dat is nou net wat ik niet wil; ik wil dat elke thread zijn eigen (gelijknamige) variable in z'n eigen memory space heeft.

Dan raad ik je aan om naar deze functies te kijken:
pthread_key_create()
pthread_getspecific()
pthread_setspecific()

[farlane]

Hm, MS specific stuff is niet echt aan te raden, portability enzo

Heeft ook niet mijn voorkeur, maar portability is niet altijd een issue imho.

Verder worden dit soort zaken (IPC) ook uitvoerig uitgelegt op deze site.
[url="http://www.cs.cf.ac.uk/Dave/C/"]http://www.cs.cf.ac.uk/Dave/C/[/url]

Interessante link. Een gedeelte legt bv heel flex uit hoe je berichten kunt versturen tussen threads mbh message queues. Die gaat naar mijn favorieten.