SCTP Multistreaming:无限循环

Question

我在SCTP上有一个简单的客户机-服务器应用程序!客户端连接到服务器，打开3个流，服务器每个流发送一个文件。问题是，我不知道如何控制3个流，知道sctp_rcvmsg()何时从流I 0，这意味着文件传输结束为该流…但sctp_recvmsg()似乎永远不会停止。这是我的代码。客户

#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <netinet/in.h>
#include <netinet/sctp.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <stdlib.h>
#include <time.h>
#define BUFFERSIZE 1024
int main(int argc, char** argv) {
int i, sockCliSCTP, flags, res;
/* Server netwrok informations */
struct sockaddr_in servAddr;
/* To get which stream it has received data from */
struct sctp_sndrcvinfo sndrcvinfo;
/* Init message to setup number of streams */
struct sctp_initmsg initmsg;
/* Catching events */
struct sctp_event_subscribe events;
/* Buffer to receive files */
char buffer[BUFFERSIZE];
/* Remove previous recently used files */
remove("first.txt");
remove("second.txt");
remove("third.txt");
char ipServ[32] = "127.0.0.1";
short int servPort = 29008;
/* BEGIN SCTP PART */
/* Creating client socket for SCTP protocol */
sockCliSCTP = socket( AF_INET, SOCK_STREAM, IPPROTO_SCTP );
/* Specify that a maximum of 3 streams will be available per socket */
memset( &initmsg, 0, sizeof(initmsg) );
initmsg.sinit_num_ostreams = 3; /* output streams */
initmsg.sinit_max_instreams = 3; /* input streams */
initmsg.sinit_max_attempts = 2;
setsockopt(sockCliSCTP, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(initmsg) );
/* Initializing server network data structs */
bzero( (void *)&servAddr, sizeof(servAddr) );
servAddr.sin_family = AF_INET;
inet_pton(AF_INET, ipServ, &servAddr.sin_addr);
servAddr.sin_port = htons(29008);
int sizeServ = sizeof(servAddr);
/* Connect to server */
res = connect(sockCliSCTP, (struct sockaddr *)&servAddr, sizeof(servAddr));
if (res < 0) {
    printf("Connection to server refused!n");
    exit(1);
}
memset( (void *)&events, 0, sizeof(events) );
events.sctp_data_io_event = 1;
res = setsockopt(sockCliSCTP, SOL_SCTP, SCTP_EVENTS, (const void *)&events, sizeof(events));
if (res < 0) {
    printf("setsockopt failed!n");
    exit(1);
}
/* The clients simply waits and receives for three files from the server.
 * The size of the files is increased each time this client is launched. */
FILE *oneF, *twoF, *threeF;
oneF = fopen("first.txt", "a"); /* Stream 0 */
twoF = fopen("second.txt", "a"); /* Stream 1 */
threeF = fopen("third.txt", "a"); /* Stream 2 */
/* To measure time */
time_t timeStart;
time_t timeEnd;
time_t timeRes = 0;
time(&timeStart);
int count0 = 0, count1 = 0, count2 = 0;
int checkRead[3];
for(i = 0; i<3; i++) {
    checkRead[i] = 1;
}

/* Receiving in parallel the files from 3 streams */
while(checkRead[0] || checkRead[1] || checkRead[2]) {
    printf("%d %d %dn", checkRead[0], checkRead[1], checkRead[2]);
    res = sctp_recvmsg(sockCliSCTP, (void*)buffer, sizeof(buffer), (struct sockaddr*)&servAddr, (socklen_t *)&sizeServ, &sndrcvinfo, &flags);
    if (res == 0) {
        printf("%d stream is zeron", sndrcvinfo.sinfo_stream);
        checkRead[sndrcvinfo.sinfo_stream] = 0;
        continue;
    }

    /* Check from which stream the data came in */
    switch(sndrcvinfo.sinfo_stream) {
    /* Write on file oneF --> first.txt */
    case 0:
        count0++;
        printf("Message received from stream 0n");
        //printf("%snn", buffer);
        fprintf(oneF, "%s", buffer);
        break;

    /* Write on file twoF --> second.txt */
    case 1:
        count1++;
        printf("Message received from stream 1n");
        //printf("%snn", buffer);
        fprintf(twoF, "%s", buffer);
        break;


    /* Write on file threeF --> third.txt */
    case 2:
        count2++;
        printf("Message received from stream 2n");
        //printf("%snn", buffer);
        fprintf(threeF, "%s", buffer);
        break;

    }
    memset(buffer, 0, sizeof(buffer));
    sleep(1);
}
close(sockCliSCTP);
time(&timeEnd);
timeRes = timeEnd - timeStart;
printf("Time elapsed is: %d secondsn", (int)timeRes);
printf("%d messages on stream 0,n %d messages on stream 1,n %d messages on stream 2n", count0, count1, count2);

}

AND THE SERVER:

#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <netinet/in.h>
#include <netinet/sctp.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFFERSIZE 1024
int main(int argc, char** argv) {
int sockCli, sockServ, one, two, three, i, res;
struct sockaddr_in client, server;
/* data struct to declarate streams */
struct sctp_initmsg initmsg;
/* buffer to read from file */
char buffer[BUFFERSIZE];
/* socket server listening */
sockServ = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
bzero( (void *)&client, sizeof(client));
bzero( (void *)&server, sizeof(server));

/* Preparing sever data struct and bind() */
bzero( (void *)&server, sizeof(server) );
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl( INADDR_ANY );
server.sin_port = htons(29008);
bind(sockServ, (struct sockaddr *)&server, sizeof(server));
/* Maximum of 3 streams will be available per socket */
memset( &initmsg, 0, sizeof(initmsg) );
initmsg.sinit_num_ostreams = 3;
initmsg.sinit_max_instreams = 3;
initmsg.sinit_max_attempts = 2;
res = setsockopt(sockServ, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(initmsg));
if (res < 0) {
    printf("setsockopt() failed!n");
    exit(1);
}

/* Preparing the three files to be sent */
one = open("files/first.txt", O_RDONLY);
if (one < 0) {
    printf("Error on opening first file!n");
    exit(1);
}
two = open("files/second.txt", O_RDONLY);
if (two < 0) {
    printf("Error on opening second file!n");
    exit(1);
}
three = open("files/third.txt", O_RDONLY);
if (three < 0) {
    printf("Error on opening third files!n");
    exit(1);
}

int checkFiles[3];
for(i=0; i<3; i++) {
    checkFiles[i] = 1;
}

res = listen(sockServ, 5);
if (res < 0) {
    printf("listen() failed!n");
    exit(1);
}

while(1) {
    ssize_t readRes;
    int len = sizeof(client);
    sockCli = accept(sockServ, (struct sockaddr*)&client, &len);
    if (sockCli < 0) {
        printf("Error on accept()!n");
        exit(1);
    }
    printf("Associated to client!n");
    while(1) {
        memset(buffer, 0, sizeof(buffer));
        if ((readRes = read(one, (void*)buffer, sizeof(buffer))) > 0) {
            sctp_sendmsg(sockCli, (void*)buffer, (size_t)strlen(buffer), NULL, 0, 0, 0, 0 /* stream number */, 0, 0);
        }

        memset(buffer, 0, sizeof(buffer));
        if ((readRes = read(two, (void*)buffer, sizeof(buffer))) > 0) {
            sctp_sendmsg(sockCli, (void*)buffer, (size_t)strlen(buffer), NULL, 0, 0, 0, 1 /* stream number */, 0, 0);
        }

        memset(buffer, 0, sizeof(buffer));
        if ((readRes = read(three, (void*)buffer, sizeof(buffer))) > 0) {
            sctp_sendmsg(sockCli, (void*)buffer, (size_t)strlen(buffer), NULL, 0, 0, 0, 2 /* stream number */, 0, 0);
        }
        else {break;}
    }
    close(sockCli);
    close(one);
    close(two);
    close(three);


}

}

我哪里出错了?(

Answer 1

sctp_recvmsg不接收来自单个流的消息。它只是返回接收到的任何消息，然后应用程序可以找出消息来自哪个流。

在客户端接收到所有数据后，执行以下代码:

res = sctp_recvmsg(sockCliSCTP, (void*)buffer, sizeof(buffer), (struct sockaddr*)&servAddr, (socklen_t *)&sizeServ, &sndrcvinfo, &flags);
if (res == 0) {
    printf("%d stream is zeron", sndrcvinfo.sinfo_stream);
    checkRead[sndrcvinfo.sinfo_stream] = 0;
    continue;
}

res变为0，因为没有收到消息，并且sndrcvinfo结构没有更改。所以 sndrcvinfo。sinfo_stream将保持与最后一条消息来自的流相等，并且您将陷入循环，因为您不会更改checkRead[]值。

还有一些其他的错误会使服务器/客户端行为奇怪。

例如，你不能在没有分段错误的情况下连续运行客户端两次，因为服务器关闭了文件描述符，并且第二次不会发送任何数据。因此，当您执行

时，您将出现分段错误:

 checkRead[sndrcvinfo.sinfo_stream] = 0;

因为sndrcvinfo将是一个空指针