[C] Foutmelding bij socket accept()

[Jarod]

Ik heb ondertussen al een paar uur op internet lopen zoeken maar ik kan maar niet vinden waar de volgende foutmelding precies op slaat. De foutmelding die ik krijg is de volgende: Resource Temporarily unavailable. Dit treedt op nadat ik een socket opgezet heb en dan als laatste de accept() methode aanroep om clients de mogelijkheid te geven te connecten.

Wat het programma moet doen: Het luistert naar de seriele poort, op het moment dat hier data op binnen komt zet hij dit in een fifo. Dit wordt vervolgens weer uitgelezen door het socket gedeelte. Vervolgens moet hij dit op een socket zetten zodat de data verder verwerkt kan worden door een java programma.
Dit moet ook andersom kunnen gebeuren, dus als op de socket data binnenkomt moet dit op een ander fifo gezet worden en dit moet dan uitgelezen worden door het serielepoort gedeelte waarna deze dit verstuurt naar het device dat aan de seriele poort hangt.
Het tegelijker tijd luisteren op de seriele poort en een socket heb ik gedaan door middel van een fork. Daarna wordt er óf geluisterd, of geschreven naar de socket en de seriele poort. Dit is niet heel netjes gedaan, het is om en om, dit gaat goed omdat de rest van het systeem toch op deze manier werkt.

De seriele verbinding werkt voor zover ik heb kunnen proberen goed, alleen gaat het dus telkens fout met het opstarten van de socket. Het gaat goed totdat het moment komt dat ik de accept() functie aanroep om het mogelijk te maken dat het client programma kan connecten. Tijdens het opstarten van mijn programma geeft die dan telkens de foutmelding: 'Resource temporarily unavailable' weer.

Ik heb ondertussen al heel veel voorbeelden op internet opgezocht en vergeleken, ik heb gezocht op google maar ook daar kan ik geen oplossing vinden voor mijn probleem. Ook heb ik er al een aantal boeken op nageslagen die gaan over C en boeken over het specifiek programmeren onder linux maar ook hier heb ik geen oplossing kunnen vinden. Overal lijken ze dezelfde soort code te gebruiken waar het dan wel goed gaat.

De code van mijn programma:

code:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termio.h>
#include <termios.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <time.h>
#include <sys/socket.h>
#include <netinet/in.h>

unsigned short port = 1221;
int fd1, fd2;

// openen van seriele poort en mogelijk maken om te lezen en schrijven
void serielePoort () {
    int fd;
    int beurtserieel = 0;
    struct termios options;
    fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY); //Open serial port S0
    if (fd < 0){
        printf("Error opening port\n");
        return;
    }
    tcgetattr(fd, &options); //Get current port settings
    cfsetispeed(&options, B9600); //Set input speed
    cfsetospeed(&options, B9600); //Set output speed
    options.c_cflag &= ~PARENB; //Clear the parity bit
    options.c_cflag &= ~CSTOPB; //Clear the stop bit
    options.c_cflag &= ~CSIZE; //Clear the character size
    options.c_cflag |= CS8; //Set charater size to 8 bits
    options.c_cflag &= ~CRTSCTS; //Clear the flow control bits
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); //Raw input mode
    options.c_cflag |= (CLOCAL | CREAD);
    tcflush(fd, TCIFLUSH);
    tcsetattr(fd, TCSANOW, &options);
    printf("Serial communication running\n");
    while(1){
        if(beurtserieel == 0){  
            //write naar com-poort, uitlezen van pipe2
            char temp[1];
            int lengte

            // temp -> lengte bericht
            read(fd2, temp, 1);                                             
            lengte = atoi(&temp[0]);
                        
            char pakket[lengte];
            pakket[0]=temp[0];
            
            //rest bericht uitlezen
            read(fd2, pakket+1, lengte); 
            
            write(fd, pakket , strlen(pakket));
            beurtserieel++;
        }
        else{
            //read van com-poort, versturen naar pipe1
            char temp[1];
                                
            read(fd, temp, 1);
            int lengte = atoi(&temp[0]);
            
            char pakket[lengte];
            pakket[0] = temp[0];
            
            read(fd, pakket+1, lengte); 
            
            //schrijven naar pipe1
            write(fd1, pakket, strlen(pakket));                                             
            beurtserieel--;
                
        }
    }
    close(fd);
    return;
}


// Socket opzetten op te lezen/schrijven
void socketVerbinding() {
    struct timespec sleep;
    struct sockaddr_in sa;
    struct sockaddr_in sd;
    int listenSocket, flags, nRetVal;
    int n = 1;
    int ret;
    FILE *clientSocket;
    sleep.tv_sec = 0;
    sleep.tv_nsec = 1000000;
    int beurtsocket = 0;
    
    listenSocket = socket(AF_INET, SOCK_STREAM, 0);
    if( listenSocket < 0 )
        printf( "socket: %s\n", strerror( errno ) );
    sa.sin_family = AF_INET;
    sa.sin_port = htons( port );
    sa.sin_addr.s_addr = htonl(INADDR_ANY);
    if( setsockopt( listenSocket, SOL_SOCKET, SO_REUSEADDR, &n, sizeof( n ) ) < 0 )
        printf( "setsockopt: SO_REUSEADDR: %s\n", strerror( errno ) );
    if( bind( listenSocket, (struct sockaddr *) &sa, sizeof(sa) ) < 0 ) 
        printf( "bind: %s\n", strerror( errno ) );
    if( listen( listenSocket, 2) < 0 )
        printf( "listen: %s\n", strerror( errno ) );
            
    // We want to listen unblocked
        if ((flags = fcntl(listenSocket, F_GETFL, 0)) < 0) 
            printf( "fcntl: F_GETFL: %s\n", strerror (errno));
        if (nRetVal ==(fcntl(listenSocket, F_SETFL, O_NONBLOCK)) < 0)
            printf( "fcntl: O_NONBLOCK: %s\n", strerror (errno));
            
               socklen_t n1 = sizeof( struct sockaddr_in );
    if( ( ret = accept( listenSocket, (struct sockaddr *) &sa, &n1 ) ) < 0 ) {
        if( errno == EAGAIN || errno == EWOULDBLOCK )
            printf("Geen resource\n");
        printf( "accept: %s\n", strerror( errno ) );
    }
    clientSocket = fdopen( ret, "a+" );
    if( !clientSocket )
    printf( "fdopen: %s\n", strerror( errno ) );
    
    if (clientSocket == NULL) {
        // Don't nuke the processor
        nanosleep (&sleep, NULL);
    }
    printf("Socket communication running\n");
    
    while(1){
        if(beurtsocket == 0){
            //berichten van de socket naar pipe2 schrijven
            char temp[20];
                    
            fgets(temp, 1, clientSocket);
            int lengte = atoi(&temp[0]);
            
            char pakket[lengte];
            pakket[0]= temp[0];
            
            fgets(pakket+1, lengte, clientSocket);
            
            write(fd2, pakket, strlen(pakket)); 
            beurtsocket++;
        }
        else{
            //uitlezen van pipe1 en dit opslaan in temp
            //temp versturen via de socket
            char temp[1];
            
            // temp -> lengte bericht
            read(fd1, temp, 1); 
            int lengte = atoi(&temp[0]);
            
            char pakket[lengte];
            pakket[0]=temp[0];
                        
            read(fd1, pakket+1, lengte);
            fputs (pakket, clientSocket);
            fflush (clientSocket);
            beurtsocket--;
        }
    }
    // Close the listening socket
    close (listenSocket);
        
    return; 
}

// main om alle onderdelen aan te roepen en op te starten
int main(){
    pid_t pid;
            
    //aanmaken van pipes tussen verschillende processen (fifo)
    char *fifo1 = "fifo1";
    char *fifo2 = "fifo2";
    if(mkfifo(fifo1, 0666) == -1){
        if(errno != EEXIST)
            printf("receiver: mkfifo1 fout");
    }
    if(mkfifo(fifo2, 0666) == -1){
        if(errno != EEXIST)
            printf("receiver: mkfifo2 fout");
    }
    
    //openen van de fifo's
    if((fd1 = open(fifo1, O_RDWR | O_NONBLOCK)) < 0)
        printf("fifo1 open failed");
    if((fd2 = open(fifo2, O_RDWR | O_NONBLOCK)) < 0)
        printf("fifo2 open failed");
    open(fifo2, O_WRONLY | O_NONBLOCK);
    
    pid = fork();
    
    //Opstarten seriele poort gedeelte
    if(pid == 0){
        serielePoort();
    }
    //Opstarten socket gedeelte
    else {
        
            socketVerbinding();
    }
    
    return 0;   
}

Ik heb ook al geprobeerd om op regel 117 het volgende te vervangen

code:

accept( listenSocket, (struct sockaddr *) &sa, &n1 )

door:

code:

accept( listenSocket, NULL, NULL)

. Maar ook dit lost het probleem niet op, de foutmelding blijft bestaan.

Ik hoop dat iemand de fout ziet zodat mijn probleem opgelost kan worden.

[Shadowman]

Het enige wat fout kan gaan is dat de socket op NONBLOCKING staat.
Het accepten van een socketverbinding van een client komt ook op NONBLOCKING te staan zodat het programma niets kan openen en ook niet wacht.

[Jarod]

Oke, dat had ik eigenlijk zelf ook wel moeten bedenken. Ik heb nu de code van de regels 113 en 114 verplaatste tot onder regels 117 t/m 121 en inplaats van hier dan 'listenSocket' de socket 'ret' mee te geven. De betreffende code wordt dan dit:

code:

// We want to listen unblocked
        if ((flags = fcntl(listenSocket, F_GETFL, 0)) < 0) 
            printf( "fcntl: F_GETFL: %s\n", strerror (errno));
            
    socklen_t n1 = sizeof( struct sockaddr_in );

    if( ( ret = accept( listenSocket, (struct sockaddr *) &sa, &n1 ) ) < 0 ) {
        if( errno == EAGAIN || errno == EWOULDBLOCK )
            printf("Geen resource\n");
        printf( "accept: %s\n", strerror( errno ) );
    }
    

    if (nRetVal ==(fcntl(ret, F_SETFL, O_NONBLOCK)) < 0)
            printf( "fcntl: O_NONBLOCK: %s\n", strerror (errno));
            
    clientSocket = fdopen( ret, "a+" );
    if( !clientSocket )
    printf( "fdopen: %s\n", strerror( errno ) );

Hierna werkt het dus wel goed als de client geconnect heeft. Bedankt voor de suggestie, kan ik eindelijk weer verder.