Commit 7f99e12e authored by Marc Hoersken's avatar Marc Hoersken
Browse files

sockfilt.c: Reduce the number of individual memory allocations 

Merge multiple internal arrays into one, even if some variables
will not not be used. They are all created with the number of
file descriptors as their size.

Also fix possible thread handle leak in CloseHandle-loop.
parent 62a01876

tests/server/sockfilt.c

+28 −50
Original line number Diff line number Diff line
@@ -666,15 +666,22 @@ static HANDLE select_ws_wait(HANDLE handle, HANDLE event) 


  return thread;

}

struct select_ws_data {

  curl_socket_t fd;      /* the original input handle   (indexed by fds) */

  curl_socket_t wsasock; /* the internal socket handle  (indexed by wsa) */

  WSAEVENT wsaevent;     /* the internal WINSOCK2 event (indexed by wsa) */

  HANDLE thread;         /* the internal threads handle (indexed by thd) */

};

static int select_ws(int nfds, fd_set *readfds, fd_set *writefds,

                     fd_set *exceptfds, struct timeval *timeout)

{

  DWORD milliseconds, wait, idx;

  WSAEVENT wsaevent, *wsaevents;

  WSANETWORKEVENTS wsanetevents;

  HANDLE handle, *handles, *threads;

  curl_socket_t sock, *fdarr, *wsasocks;

  struct select_ws_data *data;

  HANDLE handle, *handles;

  curl_socket_t sock;

  long networkevents;

  WSAEVENT wsaevent;

  int error, fds;

  HANDLE waitevent = NULL;

  DWORD nfd = 0, thd = 0, wsa = 0;
@@ -699,9 +706,9 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
    return -1;

  }



  /* allocate internal array for the original input handles */

  fdarr = malloc(nfds * sizeof(curl_socket_t));

  if(fdarr == NULL) {

  /* allocate internal array for the internal data */

  data = malloc(nfds * sizeof(struct select_ws_data));

  if(data == NULL) {

    errno = ENOMEM;

    return -1;

  }
@@ -709,40 +716,14 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
  /* allocate internal array for the internal event handles */

  handles = malloc(nfds * sizeof(HANDLE));

  if(handles == NULL) {

    free(fdarr);

    errno = ENOMEM;

    return -1;

  }



  /* allocate internal array for the internal threads handles */

  threads = malloc(nfds * sizeof(HANDLE));

  if(threads == NULL) {

    free(handles);

    free(fdarr);

    errno = ENOMEM;

    return -1;

  }



  /* allocate internal array for the internal socket handles */

  wsasocks = malloc(nfds * sizeof(curl_socket_t));

  if(wsasocks == NULL) {

    free(threads);

    free(handles);

    free(fdarr);

    free(data);

    errno = ENOMEM;

    return -1;

  }



  /* allocate internal array for the internal WINSOCK2 events */

  wsaevents = malloc(nfds * sizeof(WSAEVENT));

  if(wsaevents == NULL) {

    free(threads);

    free(wsasocks);

    free(handles);

    free(fdarr);

    errno = ENOMEM;

    return -1;

  }

  /* clear internal arrays */

  memset(data, 0, nfds * sizeof(struct select_ws_data));

  memset(handles, 0, nfds * sizeof(HANDLE));



  /* loop over the handles in the input descriptor sets */

  for(fds = 0; fds < nfds; fds++) {
@@ -760,12 +741,12 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 


    /* only wait for events for which we actually care */

    if(networkevents) {

      fdarr[nfd] = curlx_sitosk(fds);

      data[nfd].fd = curlx_sitosk(fds);

      if(fds == fileno(stdin)) {

        handle = GetStdHandle(STD_INPUT_HANDLE);

        handle = select_ws_wait(handle, waitevent);

        handles[nfd] = handle;

        threads[thd] = handle;

        data[thd].thread = handle;

        thd++;

      }

      else if(fds == fileno(stdout)) {
@@ -781,8 +762,8 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
          if(error != SOCKET_ERROR) {

            handle = (HANDLE) wsaevent;

            handles[nfd] = handle;

            wsasocks[wsa] = curlx_sitosk(fds);

            wsaevents[wsa] = wsaevent;

            data[wsa].wsasock = curlx_sitosk(fds);

            data[wsa].wsaevent = wsaevent;

            wsa++;

          }

          else {
@@ -790,7 +771,7 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
            handle = (HANDLE) curlx_sitosk(fds);

            handle = select_ws_wait(handle, waitevent);

            handles[nfd] = handle;

            threads[thd] = handle;

            data[thd].thread = handle;

            thd++;

          }

        }
@@ -816,7 +797,7 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
  /* loop over the internal handles returned in the descriptors */

  for(idx = 0; idx < nfd; idx++) {

    handle = handles[idx];

    sock = fdarr[idx];

    sock = data[idx].fd;

    fds = curlx_sktosi(sock);



    /* check if the current internal handle was triggered */
@@ -876,22 +857,19 @@ static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, 
  }



  for(idx = 0; idx < wsa; idx++) {

    WSAEventSelect(wsasocks[idx], NULL, 0);

    WSACloseEvent(wsaevents[idx]);

    WSAEventSelect(data[idx].wsasock, NULL, 0);

    WSACloseEvent(data[idx].wsaevent);

  }



  for(idx = 0; idx < thd; idx++) {

    WaitForSingleObject(threads[thd], INFINITE);

    CloseHandle(threads[thd]);

    WaitForSingleObject(data[idx].thread, INFINITE);

    CloseHandle(data[idx].thread);

  }



  CloseHandle(waitevent);



  free(wsaevents);

  free(wsasocks);

  free(threads);

  free(handles);

  free(fdarr);

  free(data);



  return ret;

}