title: Closing libUV Handles Correctly
body: <p>I'm trying to find out how to fix these memory leaks I'm getting while running this program with Valgrind. The leaks occur with the two allocations in <code>nShell_client_main</code>. But I'm not
  sure how to properly free them.</p>
  
  <p>I've tried freeing them at nShell_Connect, but it's causing libUV to abort the program. I've tried freeing them at the end of <code>nShell_client_main</code>, but then I get read/write errors when closing the loop. Does anyone know how I'm supposed to close these handles? I've read <a href="http://nikhilm.github.io/uvbook/networking.html#tcp" rel="noreferrer">this</a>, which got me started. But, it seams out-dated because <code>uv_ip4_addr</code> has a different prototype in the latest version.</p>
  
  <p>(<code>nShell_main</code> is the "entry" point)</p>
  
  <pre><code>#include "nPort.h"
  #include "nShell-main.h"
  
  void nShell_Close(
      uv_handle_t * term_handle
  ){
  }
  
  void nShell_Connect(uv_connect_t * term_handle, int status){
      uv_close((uv_handle_t *) term_handle, 0);
  }
  
  nError * nShell_client_main(nShell * n_shell, uv_loop_t * n_shell_loop){
  
      int uv_error = 0;
  
      nError * n_error = 0;
  
      uv_tcp_t * n_shell_socket = 0;
      uv_connect_t * n_shell_connect = 0;
  
      struct sockaddr_in dest_addr;
  
      n_shell_socket = malloc(sizeof(uv_tcp_t));
  
      if (!n_shell_socket){
          // handle error
      }
  
      uv_error = uv_tcp_init(n_shell_loop, n_shell_socket);
  
      if (uv_error){
          // handle error
      }
  
      uv_error = uv_ip4_addr("127.0.0.1", NPORT, &amp;dest_addr);
  
      if (uv_error){
          // handle error
      }
  
      n_shell_connect = malloc(sizeof(uv_connect_t));
  
      if (!n_shell_connect){
          // handle error
      }
  
      uv_error = uv_tcp_connect(n_shell_connect, n_shell_socket, (struct sockaddr *) &amp;dest_addr, nShell_Connect);
  
      if (uv_error){
          // handle error
      }
  
      uv_error = uv_run(n_shell_loop, UV_RUN_DEFAULT);
  
      if (uv_error){
          // handle error
      }
  
      return 0;
  }
  
  nError * nShell_loop_main(nShell * n_shell){
  
      int uv_error = 0;
  
      nError * n_error = 0;
  
      uv_loop_t * n_shell_loop = 0;
  
      n_shell_loop = malloc(sizeof(uv_loop_t));
  
      if (!n_shell_loop){
          // handle error
      }
  
      uv_error = uv_loop_init(n_shell_loop);
  
      if (uv_error){
          // handle error
      }
  
      n_error = nShell_client_main(n_shell, n_shell_loop);
  
      if (n_error){
          // handle error
      }
  
      uv_loop_close(n_shell_loop);
      free(n_shell_loop);
  
      return 0;
  }
  </code></pre>
  
  <p>The assertion is happening at the end of the switch statement in this excerpt of code (taken from Joyent's libUV page on Github):</p>
  
  <pre><code>void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
    assert(!(handle-&gt;flags &amp; (UV_CLOSING | UV_CLOSED)));
  
    handle-&gt;flags |= UV_CLOSING;
    handle-&gt;close_cb = close_cb;
  
    switch (handle-&gt;type) {
    case UV_NAMED_PIPE:
      uv__pipe_close((uv_pipe_t*)handle);
      break;
  
    case UV_TTY:
      uv__stream_close((uv_stream_t*)handle);
      break;
  
    case UV_TCP:
      uv__tcp_close((uv_tcp_t*)handle);
      break;
  
    case UV_UDP:
      uv__udp_close((uv_udp_t*)handle);
      break;
  
    case UV_PREPARE:
      uv__prepare_close((uv_prepare_t*)handle);
      break;
  
    case UV_CHECK:
      uv__check_close((uv_check_t*)handle);
      break;
  
    case UV_IDLE:
      uv__idle_close((uv_idle_t*)handle);
      break;
  
    case UV_ASYNC:
      uv__async_close((uv_async_t*)handle);
      break;
  
    case UV_TIMER:
      uv__timer_close((uv_timer_t*)handle);
      break;
  
    case UV_PROCESS:
      uv__process_close((uv_process_t*)handle);
      break;
  
    case UV_FS_EVENT:
      uv__fs_event_close((uv_fs_event_t*)handle);
      break;
  
    case UV_POLL:
      uv__poll_close((uv_poll_t*)handle);
      break;
  
    case UV_FS_POLL:
      uv__fs_poll_close((uv_fs_poll_t*)handle);
      break;
  
    case UV_SIGNAL:
      uv__signal_close((uv_signal_t*) handle);
      /* Signal handles may not be closed immediately. The signal code will */
      /* itself close uv__make_close_pending whenever appropriate. */
      return;
  
    default:
      assert(0); // assertion is happening here
    }
  
    uv__make_close_pending(handle);
  }
  </code></pre>
  
  <p>I could call <code>uv__tcp_close</code> manually, but it's not in the public headers (and probably not the right solution anyway).</p>