C ++动态数组在分配时导致分段错误

Question

I am doing a application witch uses sockets so I am holding in an array the sockets handles.I have the following code:

while(0 == 0){
    int * tx = (int*)(malloc((nr_con + 2) * sizeof(int)));
    if (conexiuni != NULL)
    {
        syslog(LOG_NOTICE,"Ajung la eliberare %d",nr_con);
        memcpy(&tx[0],&conexiuni[0],(sizeof(int) * (nr_con)));
        syslog(LOG_NOTICE,"Ajung la eliberare %d",nr_con);
        free(conexiuni);
    }
    conexiuni = tx;

    syslog(LOG_NOTICE,"Ajung la mama %d",nr_con);
    //The line bellow causes a segfault at second connection
    if ((conexiuni[nr_con] = accept(hsock,(sockaddr*)(&sadr),&addr_size)) != -1)
    {
        nr_con++;
        syslog(LOG_NOTICE,"Primesc de la %s",inet_ntoa(sadr.sin_addr));
        syslog(LOG_NOTICE,"kkt %d",conexiuni[nr_con - 1]);
        int * sz = (int*)malloc(sizeof(int));
        *sz = conexiuni[nr_con - 1];
        syslog(LOG_NOTICE,"after %d",*sz);
        pthread_create(&tidi,0,&ConexiuniHandler, sz);
    }
}

When I connect the second time when I assign the array the program crashes. What am I doing wrong? I tried the same code on Windows and it works well but on Linux it crashes.

Answer 1

Use a std::vector .

Oops! Your answer couldn't be submitted because:
body must be at least 30 characters; you entered 19

Answer 2

I assume that what you are wanting to do is to have a server that is accepting connections and then as the connections are accepted, you start a thread to handle that connection request. So each time you do an accept you are wanting to start up a thread and give it the socket handle. You are also keeping up with all of the socket handles in an array which is dynamically increased as you accept new connection requests.

Following is a suggested method. I have not done any testing nor have I even compiled this code segment however it is a place to start. One thing that I am doing is increasing the array of socket handles by blocks of 16 each time I do a resize of the array. I am doing this because it can make the job of the memory manager a bit easier and reduce the amount of fragmentation by reducing the number of calls to malloc() .

int nr_con = 0;      // we start off with no connections
int block_con = 16;  // number of blocks to allocate each time we increase the array
SOCKET  *conexiuni = malloc ((nr_con + block_con) * sizeof(SOCKET));
while(1) {
    syslog (LOG_NOTICE, "Ajung la mama %d", nr_con);

    // wait for a connection request to come in.  if it does, log the request
    // then create a thread to handle the request providing the socket to the thread.
    // we are keeping an array of the sockets that is dynamically increased so
    // we will allocate blocks of 16 at a time as we lengthen the array.
    if ((conexiuni[nr_con] = accept (hsock, (sockaddr*)(&sadr), &addr_size)) != -1)
    {
        block_con--;
        if (block_con < 1) {
        {
            // so lets add another block to our array by allocating the memory
            // then copying the current array to the new memory area then freeing
            // the old memory area which is no longer needed.
            block_con = 16;
            SOCKET *pTemp = malloc(nr_con + block_con) * sizeof(SOCKET));
            syslog (LOG_NOTICE, "Ajung la eliberare %d", nr_con);
            memcpy (pTemp, conexiuni, (sizeof(SOCKET) * (nr_con + 1)));
            syslog (LOG_NOTICE, "Ajung la eliberare %d", nr_con);
            free (conexiuni);
            conexiuni = pTemp;
        }
        syslog (LOG_NOTICE, "Primesc de la %s", inet_ntoa(sadr.sin_addr));
        syslog (LOG_NOTICE, "kkt %d", conexiuni[nr_con]);

        SOCKET  *sz = conexiumi + nr_con;
        syslog (LOG_NOTICE, "after %d", *sz);

        // start the thread which is to service this connection request.
        pthread_create (&tidi, 0, &ConexiuniHandler, sz);
        nr_con++;
    }
}

However there are a few issues with something like this. First of all in the example above I am not handling an out of memory error should malloc() return a NULL pointer due to being unable to provide the memory request.

The second issue is the possibility that the thread will not access the pointer to the socket before the array is dynamically extended rendering the pointer provided invalid since it was freed during the dynamic reallocation. So if you have lots of connections coming in quickly, this may be a problem. At a minimum the first thing the thread should do is make a local copy of the socket handle.

Another question is how are you going to go back over the array to determine which sockets are still valid and open and which are stale with the connection closed. Do you just keep dynamically allocating space as connection requests come in until you run out of memory after a few days of your server being up and running?

Rather than using int, you really should be using SOCKET since that it the actual data type. I realize that in most cases, a SOCKET is actually an int, however it is usually better to be precise in these matters.